Hojun-Cho
a376ec89eb
Hare's canonical runtime allocator is rt::malloc with linker symbol
rt.malloc (ref/hare/rt/malloc.ha:27,78). ww kept the dot→underscore
Plan 9 convention (CLAUDE.md rule 4) so the linker symbol becomes
rt_malloc; the lib/rt exported function name becomes malloc; ww
callers say rt.malloc(...).
The language builtin keyword stays `alloc(T)!` — unchanged from Hare
(ref/hare/hare/lex/token.ha:21 ltok::ALLOC, parse/expr.ha:398
builtin()). The rename only touches the lowered linker symbol and the
exported function name behind it; the user-facing syntax for
heap-allocation is identical to Hare.
Surface:
- rt/alloc.s: TEXT rt_alloc → TEXT rt_malloc, labels updated
- lib/rt/malloc.ww: @symbol("rt_malloc") fn malloc(...) (was rt_alloc/alloc)
- rt/ensure.ww: local FFI decl + call site updated to malloc; `!` dropped
on the direct FFI call (rt_malloc returns *void, not a tagged union)
- 18 .ww callers: rt.alloc(...) → rt.malloc(...)
- cstage cmd/wcc/check.c + wwstage selfhost/cmd/wcc/check.ww
alloc-builtin suppression gate routes through ffi_resolve("malloc")
for the lowering; the user-shadow check still keys on the BUILTIN
KEYWORD "alloc" since that is what `alloc(...)` parses as. Adding
"malloc" to the user-shadow check was unnecessary and was reverted
during pre-commit review.
- cstage cmd/w6c/cgen.c: 2× ffi_resolve("alloc") → ffi_resolve("malloc")
- wwstage cgenexpr/cgenstmt: 2× ffiresolve(c, "alloc") → ffiresolve(c, "malloc")
- Test fixtures (700_e2e, 758_cgalloc_str_field, 990_selfhost, 992_w6l_ww,
selfhost/test/tagged_ptr_ret.ww): updated inline ww sources to the new
decl + call form
This is commit 2 of 3 in the lib/rt extraction (#38). Commit 3 closes
the OOM contract — return type becomes nullable *void and the builtin
lowering null-checks + propagates nomem.
Verified 132/132 + 995_self_rebuild byte-identity (5 wwstage tools
round-trip identical) + make clean cold rebuild.
3396 lines
101 KiB
Plaintext
3396 lines
101 KiB
Plaintext
// time — clocks, instants, durations. Mirrors Hare's lib/time
|
|
// (ref/hare/time/duration.ha, instant.ha, arithm.ha,
|
|
// +linux/functions.ha). Calendar / date / strftime / timezone /
|
|
// sleep live in separate Hare modules and graduate when callers /
|
|
// supporting stdlib arrive.
|
|
//
|
|
// `duration` is a NAMED alias of i64 (lib/math/random precedent
|
|
// at lib/math/random/random.ww:8); ww treats NAMED as a newtype,
|
|
// so cross-i64 arithmetic inside this module needs explicit casts.
|
|
// Hare's structural alias semantics let those casts vanish, but
|
|
// our type checker is strict.
|
|
|
|
package time;
|
|
|
|
@symbol("rt_syscall") fn syscall2(num: i64, a: i64, b: i64) i64;
|
|
@symbol("rt_abort") fn abort(msg: str) void;
|
|
|
|
def SYS_CLOCK_GETTIME: i64 = 228;
|
|
|
|
// ref/hare/time/duration.ha:6. 290y representable range.
|
|
export type duration = i64;
|
|
|
|
// ref/hare/time/duration.ha:9-18. Plan-9 naming (lowercase)
|
|
// diverges from Hare's uppercase per project rule 4.
|
|
export def nanosecond: duration = 1i64;
|
|
export def microsecond: duration = 1000i64;
|
|
export def millisecond: duration = 1000000i64;
|
|
export def second: duration = 1000000000i64;
|
|
|
|
// ref/hare/time/instant.ha:9. (sec, nsec) pair — NOT POSIX struct
|
|
// timespec (which uses u32 nsec). Layout matches Linux's struct
|
|
// timespec on 64-bit (i64+i64) so we can pass &instant directly
|
|
// to clock_gettime.
|
|
export type instant = struct {
|
|
sec: i64,
|
|
nsec: i64,
|
|
};
|
|
|
|
// ref/hare/time/+linux/functions.ha:84. First cut exposes only
|
|
// realtime and monotonic; Hare's process_cpu / thread_cpu / boot /
|
|
// realtime_alarm / boot_alarm / tai graduate when a caller needs
|
|
// them (CLAUDE.md rule 9 — Hare-fidelity, no premature surface).
|
|
export type clock = enum i32 {
|
|
realtime = 0,
|
|
monotonic = 1,
|
|
};
|
|
|
|
// ref/hare/time/+linux/functions.ha:138. Hare's now() also aborts
|
|
// on impossible errnos. (instant | oserror) is deliberately not
|
|
// the return shape — EINVAL / EFAULT are programmer errors (bad
|
|
// clock id, bad ptr), and a 1-word-payload sum return walks into
|
|
// task #9's cgen-divergence trap.
|
|
export fn now(c: clock) instant = {
|
|
let i: instant;
|
|
let rc = syscall2(SYS_CLOCK_GETTIME, (c as i32): i64, (&i): i64);
|
|
if (rc != 0i64) { abort("time.now: clock_gettime failed"); };
|
|
return i;
|
|
};
|
|
|
|
// ref/hare/time/arithm.ha:9. Adds duration to instant. The
|
|
// negative-duration branch normalises nsec into [0, second).
|
|
export fn add(i: instant, x: duration) instant = {
|
|
let r: instant;
|
|
let xi: i64 = x: i64;
|
|
let sec: i64 = second: i64;
|
|
let nsec: i64 = nanosecond: i64;
|
|
if (xi == 0i64) {
|
|
r.sec = i.sec;
|
|
r.nsec = i.nsec;
|
|
return r;
|
|
};
|
|
if (xi > 0i64) {
|
|
r.sec = i.sec + (i.nsec + xi) / sec;
|
|
r.nsec = (i.nsec + xi) % sec;
|
|
return r;
|
|
};
|
|
r.sec = i.sec + (i.nsec + xi - sec + nsec) / sec;
|
|
r.nsec = (i.nsec + (xi % sec) + sec) % sec;
|
|
return r;
|
|
};
|
|
|
|
// ref/hare/time/arithm.ha:26. Returns duration from a to b.
|
|
// Sign convention: b - a.
|
|
export fn diff(a: instant, b: instant) duration = {
|
|
let sec: i64 = second: i64;
|
|
let v: i64 = ((b.sec - a.sec) * sec) + (b.nsec - a.nsec);
|
|
return v: duration;
|
|
};
|
|
|
|
// ref/hare/time/arithm.ha:32. -1 if a < b, 0 if equal, +1 if a > b.
|
|
export fn compare(a: instant, b: instant) i8 = {
|
|
if (a.sec < b.sec) { return -1i8; };
|
|
if (a.sec > b.sec) { return 1i8; };
|
|
if (a.nsec < b.nsec) { return -1i8; };
|
|
if (a.nsec > b.nsec) { return 1i8; };
|
|
return 0i8;
|
|
};
|
|
|
|
// 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.
|
|
|
|
package os;
|
|
|
|
import time;
|
|
|
|
@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_free") export 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,
|
|
NEWFSTATAT = 262,
|
|
};
|
|
|
|
// open(2) flags. Linux values, matching <fcntl.h>. 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);
|
|
};
|
|
|
|
// PATH_MAX / pathbuf / kpath — port of Hare's ref/hare/sys/+linux/
|
|
// syscalls.ha:25,27,29-55. Hare's `path` accepts a sum `(str |
|
|
// []u8 | *const u8)`; ww's lib/os public surface narrows to `str`
|
|
// (the Hare-faithful surface at ref/hare/os/os.ha:37,47,50 etc).
|
|
// Internally, [[kpath]] copies the `str` bytes into a single
|
|
// module-level [[pathbuf]] scratch slot and NUL-terminates so the
|
|
// raw Linux syscalls (which require C strings) see a valid
|
|
// terminator. Same precedent as Hare's static `pathbuf`.
|
|
//
|
|
// Non-reentrant: one buffer, every [[stat]] / [[open]] / etc.
|
|
// rewrites it. Same caveat as strconv's `*tos` family (overwritten
|
|
// on next call). Caller must NOT hold a kpath-returned pointer
|
|
// across another lib/os path call. Graduates when ww grows a
|
|
// thread story.
|
|
//
|
|
// `nil`-as-overflow over `(*u8 | oserror)`: wwstage over-allocates
|
|
// 1-word-payload tagged returns to 24B (cstage emits 16B).
|
|
// Task #9; revert at task #10 when fixed. Repro at
|
|
// .ai/probe_tagged_return_pointer_payload.ww.
|
|
export def PATH_MAX: i32 = 4096;
|
|
let pathbuf: [4096]u8;
|
|
|
|
fn kpath(p: str) *u8 = {
|
|
if (p.len + 1 >= PATH_MAX) { return nil: *u8; }; // ENAMETOOLONG
|
|
let i: i32 = 0;
|
|
for (i < p.len) { pathbuf[i] = p[i]; i += 1; };
|
|
pathbuf[p.len] = 0u8;
|
|
return &pathbuf[0];
|
|
};
|
|
|
|
// 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). Returns -errno on failure, fd otherwise.
|
|
// Higher-level callers prefer `tryopen`. Mirrors Hare's os::open
|
|
// (ref/hare/os/os.ha:117); kpath lands the bytes in pathbuf.
|
|
// Returns -ENAMETOOLONG (-36) if the path overflows PATH_MAX.
|
|
export fn open(path: str, flags: flag, mode: i32) i32 = {
|
|
let p: *u8 = kpath(path);
|
|
if (p == nil: *u8) { return -36i32; }; // ENAMETOOLONG
|
|
return syscall3(nr.OPEN, p: i64, (flags as i32): i64, mode: i64): i32;
|
|
};
|
|
|
|
export fn tryopen(path: str, 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 <unistd.h> (F_OK=0).
|
|
// Mirrors Hare's os::access (ref/hare/os/+linux/fs.ha:access).
|
|
// Returns -ENAMETOOLONG (-36) if the path overflows PATH_MAX.
|
|
export fn access(path: str, mode: i32) i32 = {
|
|
let p: *u8 = kpath(path);
|
|
if (p == nil: *u8) { return -36i32; };
|
|
return syscall2(nr.ACCESS, p: i64, mode: i64): i32;
|
|
};
|
|
|
|
// remove — unlink(2). Mirrors Hare's os::remove
|
|
// (ref/hare/os/os.ha:12).
|
|
export fn remove(path: str) i32 = {
|
|
let p: *u8 = kpath(path);
|
|
if (p == nil: *u8) { return -36i32; };
|
|
return syscall1(nr.UNLINK, p: i64): i32;
|
|
};
|
|
|
|
// mkdir — mkdir(2). Mode is the unix permission bitset (e.g. 0o700).
|
|
// Returns 0 on success, negative errno otherwise. Mirrors Hare's
|
|
// os::mkdir (ref/hare/os/os.ha:50).
|
|
export fn mkdir(path: str, mode: i32) i32 = {
|
|
let p: *u8 = kpath(path);
|
|
if (p == nil: *u8) { return -36i32; };
|
|
return syscall2(nr.MKDIR, p: i64, mode: i64): i32;
|
|
};
|
|
|
|
// rmdir — rmdir(2). Mirrors Hare's os::rmdir
|
|
// (ref/hare/os/os.ha:58).
|
|
export fn rmdir(path: str) i32 = {
|
|
let p: *u8 = kpath(path);
|
|
if (p == nil: *u8) { return -36i32; };
|
|
return syscall1(nr.RMDIR, p: 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`.
|
|
//
|
|
// Mirrors Hare's os::mkdirs (ref/hare/os/os.ha:54). The in-place
|
|
// '/' → NUL splice walks the kpath-loaded [[pathbuf]] directly
|
|
// instead of recursing through [[mkdir]] — re-entering kpath would
|
|
// clobber the buffer mid-walk (single static slot, see kpath's
|
|
// non-reentrancy note above).
|
|
export fn mkdirs(path: str, mode: i32) (void | oserror) = {
|
|
let cp: *u8 = kpath(path);
|
|
if (cp == nil: *u8) { return -36i64: oserror; };
|
|
let n: i32 = path.len;
|
|
if (n == 0) { return; };
|
|
|
|
// Walk forward; at each '/' boundary, NUL-terminate the prefix,
|
|
// raw MKDIR syscall on pathbuf, 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 (pathbuf[i] == 47u8) { // '/'
|
|
pathbuf[i] = 0u8;
|
|
let r: i32 = syscall2(nr.MKDIR,
|
|
(&pathbuf[0]): i64, mode: i64): i32;
|
|
pathbuf[i] = 47u8;
|
|
if (r < 0) {
|
|
if (r != -17) { return r: i64: oserror; };
|
|
};
|
|
};
|
|
i += 1;
|
|
};
|
|
|
|
let r: i32 = syscall2(nr.MKDIR,
|
|
(&pathbuf[0]): i64, mode: i64): i32;
|
|
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. Mirrors Hare's
|
|
// os::exec::exec path arg (str). argv/envp stay `**u8` — the
|
|
// kernel takes a NUL-pointer-terminated table of NUL-terminated
|
|
// C strings, a different shape from a path.
|
|
export fn execve(path: str, argv: **u8, envp: **u8) i32 = {
|
|
let p: *u8 = kpath(path);
|
|
if (p == nil: *u8) { return -36i32; };
|
|
return syscall3(nr.EXECVE, p: 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_malloc / 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;
|
|
};
|
|
|
|
// ---- stat / lstat / fstat / exists -----------------------------------
|
|
//
|
|
// Ports of Hare's stat family (ref/hare/fs/fs.ha:172,196 +
|
|
// ref/hare/sys/+linux/stat.ha:24-58). The Hare surface returns
|
|
// `filestat` by value; ww's cgreturn ABI tops out at 24B today (see
|
|
// STATUS task #21) and filestat is 80B, so [[stat]] / [[lstat]] /
|
|
// [[fstat]] take an out-parameter and return `(void | oserror)`.
|
|
// Re-evaluate the by-value shape when full sret lands.
|
|
//
|
|
// `filestat`, `mode`, and `stat_mask` live in lib/os because ww has
|
|
// no lib/fs yet; Hare puts them in `fs::`. These types graduate to
|
|
// lib/fs when that module ships — callers should expect a future
|
|
// re-export.
|
|
//
|
|
// Underlying syscall is SYS_newfstatat (262), which unifies
|
|
// stat/lstat/fstat through the `dirfd + flags` triple:
|
|
// stat = newfstatat(AT_FDCWD, path, 0)
|
|
// lstat = newfstatat(AT_FDCWD, path, AT_SYMLINK_NOFOLLOW)
|
|
// fstat = newfstatat(fd, "", AT_EMPTY_PATH)
|
|
// Avoiding SYS_statx — its 256B variable layout would buy btime,
|
|
// but Hare's filestat doesn't expose btime either, so we stay on
|
|
// the simpler 144B kernel struct.
|
|
|
|
// fstatat(2) flag values. Linux constants from <linux/fcntl.h>.
|
|
// Names mirror Hare's ref/hare/sys/+linux/types.ha:45-51 (capital-
|
|
// AT_ prefix, top-level `def`s).
|
|
export def AT_FDCWD: i32 = -100;
|
|
export def AT_SYMLINK_NOFOLLOW: i32 = 256; // 0x100
|
|
export def AT_EMPTY_PATH: i32 = 4096; // 0x1000
|
|
|
|
// mode — file-mode bits. Mirrors Hare's fs::mode (ref/hare/fs/
|
|
// types.ha:63). Permission bits are the standard Unix octal subset;
|
|
// type bits live in the S_IFMT = 0o170000 region. Type-bit test:
|
|
//
|
|
// let t: u32 = (fi.mode as u32) & 61440u32; // 0o170000 mask
|
|
// if (t == os.mode.DIR as u32) { /* directory */ };
|
|
//
|
|
// Numeric values are octal in Hare's source; ww has no octal
|
|
// literals so they're written as decimal with the octal in a
|
|
// trailing comment.
|
|
export type mode = enum u32 {
|
|
// permission bits
|
|
USER_RWX = 448u32, // 0o700
|
|
USER_RW = 384u32, // 0o600
|
|
USER_RX = 320u32, // 0o500
|
|
USER_R = 256u32, // 0o400
|
|
USER_W = 128u32, // 0o200
|
|
USER_X = 64u32, // 0o100
|
|
GROUP_RWX = 56u32, // 0o070
|
|
GROUP_RW = 48u32, // 0o060
|
|
GROUP_RX = 40u32, // 0o050
|
|
GROUP_R = 32u32, // 0o040
|
|
GROUP_W = 16u32, // 0o020
|
|
GROUP_X = 8u32, // 0o010
|
|
OTHER_RWX = 7u32, // 0o007
|
|
OTHER_RW = 6u32, // 0o006
|
|
OTHER_RX = 5u32, // 0o005
|
|
OTHER_R = 4u32, // 0o004
|
|
OTHER_W = 2u32, // 0o002
|
|
OTHER_X = 1u32, // 0o001
|
|
SETUID = 2048u32, // 0o4000
|
|
SETGID = 1024u32, // 0o2000
|
|
STICKY = 512u32, // 0o1000
|
|
// file-type bits (S_IFMT mask = 0o170000 = 61440)
|
|
UNKNOWN = 0u32,
|
|
FIFO = 4096u32, // 0o010000
|
|
CHR = 8192u32, // 0o020000
|
|
DIR = 16384u32, // 0o040000
|
|
BLK = 24576u32, // 0o060000
|
|
REG = 32768u32, // 0o100000
|
|
LINK = 40960u32, // 0o120000
|
|
SOCK = 49152u32, // 0o140000
|
|
};
|
|
|
|
// stat_mask — which filestat fields the call populated. Mirrors
|
|
// Hare's fs::stat_mask (ref/hare/fs/types.ha:129). newfstatat fills
|
|
// every field, so [[stat]] / [[lstat]] / [[fstat]] always set all
|
|
// seven bits OR-folded (see [[fillfilestat]]); per-bit testing is
|
|
// the documented sparse-backend pattern (cf. Hare's fs::fs network
|
|
// backends that only populate mtime+size).
|
|
export type stat_mask = enum u32 {
|
|
UID = 1u32,
|
|
GID = 2u32,
|
|
SIZE = 4u32,
|
|
INODE = 8u32,
|
|
ATIME = 16u32,
|
|
MTIME = 32u32,
|
|
CTIME = 64u32,
|
|
};
|
|
|
|
// filestat — Hare's fs::filestat (ref/hare/fs/types.ha:141). 80
|
|
// bytes. Times are time.instant (ref/hare/time/instant.ha:9) — the
|
|
// canonical Hare shape. See module-header note re: graduation to
|
|
// lib/fs.
|
|
export type filestat = struct {
|
|
mask: stat_mask, // 0 (4)
|
|
mode: mode, // 4 (4)
|
|
uid: u32, // 8 (4)
|
|
gid: u32, // 12 (4)
|
|
sz: u64, // 16 (8)
|
|
inode: u64, // 24 (8)
|
|
atime: time.instant, // 32 (16)
|
|
mtime: time.instant, // 48 (16)
|
|
ctime: time.instant, // 64 (16) — ends at 80
|
|
};
|
|
|
|
// kstat — x86_64 kernel `struct stat` layout. Mirrors
|
|
// arch/x86/include/uapi/asm/stat.h (`__kernel_ulong_t`-keyed
|
|
// fields). 144 bytes. Module-internal; SYS_newfstatat writes into
|
|
// this buffer and the public stat fns then copy the bits into the
|
|
// Hare-shaped [[filestat]].
|
|
type kstat = struct {
|
|
dev: u64, // 0
|
|
ino: u64, // 8
|
|
nlink: u64, // 16
|
|
mode: u32, // 24
|
|
uid: u32, // 28
|
|
gid: u32, // 32
|
|
pad0: u32, // 36
|
|
rdev: u64, // 40
|
|
sz: i64, // 48
|
|
blksize: i64, // 56
|
|
blocks: i64, // 64
|
|
atime_sec: i64, // 72
|
|
atime_nsec: i64, // 80
|
|
mtime_sec: i64, // 88
|
|
mtime_nsec: i64, // 96
|
|
ctime_sec: i64, // 104
|
|
ctime_nsec: i64, // 112
|
|
unused0: i64, // 120
|
|
unused1: i64, // 128
|
|
unused2: i64, // 136 — ends at 144
|
|
};
|
|
|
|
// emptypath — single-NUL byte used as the `pathname` arg to
|
|
// newfstatat with AT_EMPTY_PATH. The kernel requires a non-NULL
|
|
// pointer to a zero-length C string, NOT a null pointer. Bytes are
|
|
// read-only from the kernel's view; ww has no module-level const so
|
|
// this is a writable `let`.
|
|
let emptypath: [1]u8 = [0u8];
|
|
|
|
// fillfilestat — copy a 144B kstat into the 80B Hare-shaped
|
|
// filestat. Internal helper used by all three public entry points.
|
|
// Mirrors Hare's st_to_filestat (ref/hare/os/+linux/dirfdfs.ha:259):
|
|
// newfstatat populates every field, so the mask is the OR-fold of
|
|
// all seven Hare stat_mask bits.
|
|
fn fillfilestat(out: *filestat, k: *kstat) void = {
|
|
out.mask = stat_mask.UID | stat_mask.GID | stat_mask.SIZE
|
|
| stat_mask.INODE | stat_mask.ATIME | stat_mask.MTIME
|
|
| stat_mask.CTIME;
|
|
out.mode = k.mode: mode;
|
|
out.uid = k.uid;
|
|
out.gid = k.gid;
|
|
out.sz = k.sz: u64;
|
|
out.inode = k.ino;
|
|
out.atime.sec = k.atime_sec;
|
|
out.atime.nsec = k.atime_nsec;
|
|
out.mtime.sec = k.mtime_sec;
|
|
out.mtime.nsec = k.mtime_nsec;
|
|
out.ctime.sec = k.ctime_sec;
|
|
out.ctime.nsec = k.ctime_nsec;
|
|
};
|
|
|
|
// stat — fill *out with metadata for `path`. Follows symlinks.
|
|
// Returns ENAMETOOLONG (-36) as `oserror` if the path overflows
|
|
// PATH_MAX.
|
|
//
|
|
// Mirrors Hare's sys::stat (ref/hare/sys/+linux/stat.ha:51) modulo
|
|
// the out-param shape forced by the cgreturn 24B cap. Note: Hare's
|
|
// higher-level fs::stat (ref/hare/fs/fs.ha:172) instead has lstat
|
|
// semantics — we follow sys::stat's POSIX-stat behavior here.
|
|
export fn stat(out: *filestat, path: str) (void | oserror) = {
|
|
let cp: *u8 = kpath(path);
|
|
if (cp == nil: *u8) { return -36i64: oserror; };
|
|
let k: kstat;
|
|
let r: i64 = syscall4(nr.NEWFSTATAT,
|
|
AT_FDCWD: i64, cp: i64, (&k): i64, 0i64);
|
|
if (r < 0) { return r: oserror; };
|
|
fillfilestat(out, &k);
|
|
};
|
|
|
|
// lstat — like [[stat]] but does NOT follow a terminal symlink.
|
|
// Mirrors Hare's sys::lstat (ref/hare/sys/+linux/stat.ha:57).
|
|
export fn lstat(out: *filestat, path: str) (void | oserror) = {
|
|
let cp: *u8 = kpath(path);
|
|
if (cp == nil: *u8) { return -36i64: oserror; };
|
|
let k: kstat;
|
|
let r: i64 = syscall4(nr.NEWFSTATAT,
|
|
AT_FDCWD: i64, cp: i64, (&k): i64,
|
|
AT_SYMLINK_NOFOLLOW: i64);
|
|
if (r < 0) { return r: oserror; };
|
|
fillfilestat(out, &k);
|
|
};
|
|
|
|
// fstat — like [[stat]] but addresses the file by fd. Uses
|
|
// newfstatat(fd, "", AT_EMPTY_PATH); the kernel resolves the fd
|
|
// directly. Mirrors Hare's sys::fstat (ref/hare/sys/+linux/stat.ha:54).
|
|
export fn fstat(out: *filestat, fd: i32) (void | oserror) = {
|
|
let k: kstat;
|
|
let r: i64 = syscall4(nr.NEWFSTATAT,
|
|
fd: i64, (&emptypath[0]): i64, (&k): i64,
|
|
AT_EMPTY_PATH: i64);
|
|
if (r < 0) { return r: oserror; };
|
|
fillfilestat(out, &k);
|
|
};
|
|
|
|
// exists — true if `path` resolves to anything (regular file,
|
|
// directory, symlink, ...). Stat-shaped (Hare's `fs::exists`,
|
|
// ref/hare/fs/fs.ha:196) — no separate syscall. Symlinks are
|
|
// followed; a dangling symlink is `false`. ENAMETOOLONG is
|
|
// swallowed as `false` — Hare's os::exists doc says "true if a
|
|
// node exists at the given path, or false if not."
|
|
//
|
|
// Race warning: prefer "open and handle the error" over "exists
|
|
// then open" in real code (Hare's docstring carries the same
|
|
// note). The race is unavoidable in this shape.
|
|
//
|
|
// Goes through SYS_newfstatat directly rather than match'ing on
|
|
// [[stat]]'s `(void | oserror)` return. Functionally identical;
|
|
// the direct shape sidesteps a cstage/wwstage cgen disagreement
|
|
// on the slot size of `(void | oserror)` (cstage 16B, wwstage 24B
|
|
// — same class as STATUS #22, surfaced first time a match on this
|
|
// shape combined with an 80B local-struct local frame). Use the
|
|
// match shape once #22 lands.
|
|
export fn exists(path: str) bool = {
|
|
let cp: *u8 = kpath(path);
|
|
if (cp == nil: *u8) { return false; };
|
|
let k: kstat;
|
|
let r: i64 = syscall4(nr.NEWFSTATAT,
|
|
AT_FDCWD: i64, cp: i64, (&k): i64, 0i64);
|
|
return r >= 0i64;
|
|
};
|
|
|
|
// rt — runtime primitives exposed to ww programs.
|
|
// Mirrors Hare's rt:: module placement (ref/hare/rt/).
|
|
|
|
package rt;
|
|
|
|
// malloc — mmap-backed page allocator. Untyped: `malloc(n)` returns a
|
|
// `*void`; callers cast to the target type. Diverges from Hare: Hare
|
|
// exposes `alloc` / `free` as typed language builtins that the
|
|
// compiler lowers to rt::malloc/rt::free; ww has no such builtins,
|
|
// so the rt-symbol surface is exposed directly. Stdlib callers that
|
|
// need a typed allocation pattern wrap this with a cast plus a stored
|
|
// capacity (see [[strings.dup]], [[memio.dynamic]]).
|
|
//
|
|
// OOM: rt_malloc is a bare mmap(MAP_ANON|MAP_PRIVATE) wrapper with no
|
|
// error path. The raw Linux mmap syscall returns a negative errno cast
|
|
// to `*void` on failure (e.g. `(void*)-12` for ENOMEM); the
|
|
// `MAP_FAILED` (`(void*)-1`) value is a libc-wrapper convention that
|
|
// rt_malloc doesn't apply. Neither `== nil` nor `== (void*)-1` catches
|
|
// it; any deref of such a return faults. Today the stdlib does not
|
|
// check; OOM faults on first dereference. A typed fallible variant is
|
|
// a future task (task #39). ref/hare/rt/malloc.ha:27.
|
|
@symbol("rt_malloc") export fn malloc(n: u64) *void;
|
|
|
|
// selfhost/cmd/wcc/mem.ww — port of cmd/wcc/mem.c.
|
|
//
|
|
// Bump arena allocator. Backed by the runtime page allocator
|
|
// (rt_malloc / 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.
|
|
|
|
package wcc;
|
|
|
|
import os;
|
|
import rt;
|
|
|
|
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 = rt.malloc(ARENA_SZ): *arena;
|
|
a.buf = rt.malloc(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 = rt.malloc(ARENA_SZ): *arena;
|
|
old.buf = a.buf;
|
|
old.off = a.off;
|
|
old.cap = a.cap;
|
|
old.next = a.next;
|
|
old.total = 0u64;
|
|
|
|
a.buf = rt.malloc(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/w6l/sym.ww — port of cmd/w6l/sym.c.
|
|
//
|
|
// Linker symbol table. Singly-linked list, usually a few hundred
|
|
// entries; hashing isn't worth it yet.
|
|
|
|
package w6l;
|
|
|
|
import mem;
|
|
|
|
type lsym = struct {
|
|
name: str,
|
|
val: u64, // offset within combined .text (or .data when
|
|
// indata=1) once linked
|
|
defined: i32, // 1 if some lobj defines this symbol
|
|
indata: i32, // 1 if defined in .data (writable globals)
|
|
owner: *lobj,
|
|
idxinowner: i32,
|
|
// Dynamic-linking fields. Set by resolve when an undefined sym
|
|
// is provided by some loaded lso. pltidx and dynsymidx default
|
|
// to -1 (set explicitly by resolve; alloc-zeroing gives 0, not -1).
|
|
isdyn: i32,
|
|
dynlib: *lso,
|
|
dynversion: str, // matched export's version; len 0 if none
|
|
pltidx: i32,
|
|
dynsymidx: i32,
|
|
snext: *lsym,
|
|
};
|
|
|
|
type lrel = struct {
|
|
off: u64, // offset within the relocation's section
|
|
section: i32, // 0 = .text, 1 = .data
|
|
kind: i32, // R_X86_64_*
|
|
sym: *lsym,
|
|
addend: i64,
|
|
rnext: *lrel,
|
|
};
|
|
|
|
type lobj = struct {
|
|
path: str,
|
|
buf: *u8, // object bytes
|
|
len: u64,
|
|
textoff: u64, // offset of .text in combined output
|
|
textsize: u64,
|
|
dataoff: u64, // offset of .data in combined output
|
|
datasize: u64, // bytes contributed to combined .data (0 if none)
|
|
onext: *lobj,
|
|
};
|
|
|
|
// lexport — one entry per GLOBAL/WEAK symbol exported by a loaded .so.
|
|
// Stored as a chain in the order the .so's dynsym presents them, so
|
|
// soprovides_v's first-match semantics agree with the C version.
|
|
type lexport = struct {
|
|
name: str,
|
|
version: str, // len 0 for unversioned globals
|
|
enext: *lexport,
|
|
};
|
|
|
|
type lso = struct {
|
|
path: str, // full filesystem path used to load
|
|
soname: str, // DT_SONAME, or basename if missing
|
|
exports: *lexport, // dynsym-order chain of exported names
|
|
sonext: *lso,
|
|
};
|
|
|
|
type lnk = struct {
|
|
a: *arena,
|
|
objs: *lobj,
|
|
sos: *lso,
|
|
syms: *lsym,
|
|
rels: *lrel,
|
|
text: *u8, // combined .text
|
|
textcap: u64,
|
|
textlen: u64,
|
|
// Combined .data (writable). Empty unless any input .o has a
|
|
// .data PROGBITS section.
|
|
data: *u8,
|
|
datacap: u64,
|
|
datalen: u64,
|
|
errs: i32,
|
|
dynn: i32, // number of syms routed through PLT
|
|
};
|
|
|
|
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;
|
|
};
|
|
|
|
export fn intern(l: *lnk, name: str) *lsym = {
|
|
let s: *lsym = l.syms;
|
|
for (s != nil) {
|
|
if (streq(s.name, name)) { return s; };
|
|
s = s.snext;
|
|
};
|
|
let n: *lsym = alloc(lsym { name = name, snext = l.syms })!;
|
|
l.syms = n;
|
|
return n;
|
|
};
|
|
|
|
export fn lookup(l: *lnk, name: str) *lsym = {
|
|
let s: *lsym = l.syms;
|
|
for (s != nil) {
|
|
if (streq(s.name, name)) { return s; };
|
|
s = s.snext;
|
|
};
|
|
return nil;
|
|
};
|
|
|
|
// selfhost/cmd/w6l/obj.ww — port of cmd/w6l/obj.c.
|
|
//
|
|
// Loads relocatable ELF64 .o files emitted by w6a, appends .text to
|
|
// the combined image, and pulls in symbols + relocations with
|
|
// offsets adjusted to the combined section.
|
|
//
|
|
// Also handles SysV `ar` archives (libwwrt.a). The two-pass loader
|
|
// indexes members on the first pass and iteratively pulls members
|
|
// that define currently-undefined symbols on subsequent passes.
|
|
|
|
package w6l;
|
|
|
|
import os;
|
|
import rt;
|
|
import mem;
|
|
import sym;
|
|
|
|
def ET_REL: i32 = 1;
|
|
def EM_X86_64: i32 = 62;
|
|
def SHT_PROGBITS: i32 = 1;
|
|
def SHT_SYMTAB: i32 = 2;
|
|
def SHT_STRTAB: i32 = 3;
|
|
def SHT_RELA: i32 = 4;
|
|
|
|
// ---- little-endian byte readers ----------------------------------------
|
|
// w6a/w6l use straight LE on amd64. Reading via byte offsets keeps us off
|
|
// the cgen's u16 field-load story for now (MOVZBQ exists; MOVZWQ doesn't).
|
|
|
|
fn rdu16(p: *u8, off: u64) u16 = {
|
|
let b0: u16 = p[off]: u16;
|
|
let b1: u16 = p[off + 1u64]: u16;
|
|
return b0 | (b1 << 8u16);
|
|
};
|
|
|
|
fn rdu32(p: *u8, off: u64) u32 = {
|
|
let b0: u32 = p[off]: u32;
|
|
let b1: u32 = p[off + 1u64]: u32;
|
|
let b2: u32 = p[off + 2u64]: u32;
|
|
let b3: u32 = p[off + 3u64]: u32;
|
|
return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32);
|
|
};
|
|
|
|
fn rdu64(p: *u8, off: u64) u64 = {
|
|
let lo: u64 = rdu32(p, off): u64;
|
|
let hi: u64 = rdu32(p, off + 4u64): u64;
|
|
return lo | (hi << 32u64);
|
|
};
|
|
|
|
// ---- ELF64 section header offsets (40 bytes total) --------------------
|
|
def SHDR_SIZE: u64 = 64u64; // sizeof(Shdr) per ELF64 spec
|
|
def SHDR_NAME: u64 = 0u64;
|
|
def SHDR_TYPE: u64 = 4u64;
|
|
def SHDR_OFFSET: u64 = 24u64;
|
|
def SHDR_SIZE_F: u64 = 32u64;
|
|
def SHDR_LINK: u64 = 40u64;
|
|
|
|
// ELF64 ehdr field offsets
|
|
def EHDR_SIZE: u64 = 64u64;
|
|
def EHDR_TYPE: u64 = 16u64;
|
|
def EHDR_MACHINE: u64 = 18u64;
|
|
def EHDR_SHOFF: u64 = 40u64;
|
|
def EHDR_SHENTSIZE: u64 = 58u64;
|
|
def EHDR_SHNUM: u64 = 60u64;
|
|
def EHDR_SHSTRNDX: u64 = 62u64;
|
|
|
|
// ELF64 sym entry: 24 bytes
|
|
def SYM_SIZE: u64 = 24u64;
|
|
def SYM_NAME: u64 = 0u64;
|
|
def SYM_INFO: u64 = 4u64;
|
|
def SYM_SHNDX: u64 = 6u64;
|
|
def SYM_VALUE: u64 = 8u64;
|
|
|
|
// ELF64 RELA entry: 24 bytes
|
|
def RELA_SIZE: u64 = 24u64;
|
|
def RELA_OFFSET: u64 = 0u64;
|
|
def RELA_INFO: u64 = 8u64;
|
|
def RELA_ADDEND: u64 = 16u64;
|
|
|
|
// ---- file slurp --------------------------------------------------------
|
|
|
|
fn slurp(path: *u8) (*u8, u64) = {
|
|
let fd: i32 = os.open(pathstr(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 buf: *u8 = rt.malloc(n: u64): *u8;
|
|
let rr: (i64 | os.oserror) = os.readall(fd, buf, n: u64);
|
|
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; };
|
|
return buf, n: u64;
|
|
};
|
|
|
|
// ---- text buffer growth ------------------------------------------------
|
|
|
|
fn emittext(l: *lnk, src: *u8, n: u64) void = {
|
|
if (l.textlen + n > l.textcap) {
|
|
let nc: u64 = l.textcap;
|
|
if (nc == 0u64) { nc = 4096u64; };
|
|
for (nc < l.textlen + n) { nc = nc * 2u64; };
|
|
// Grow by mmap'ing a fresh region and copying. The old buffer
|
|
// is leaked into the page allocator; for a linker run this is
|
|
// trivial waste.
|
|
let nb: *u8 = rt.malloc(nc): *u8;
|
|
let i: u64 = 0u64;
|
|
for (i < l.textlen) {
|
|
nb[i] = l.text[i];
|
|
i += 1u64;
|
|
};
|
|
l.text = nb;
|
|
l.textcap = nc;
|
|
};
|
|
let i: u64 = 0u64;
|
|
for (i < n) {
|
|
l.text[l.textlen + i] = src[i];
|
|
i += 1u64;
|
|
};
|
|
l.textlen += n;
|
|
};
|
|
|
|
fn emitdata(l: *lnk, src: *u8, n: u64) void = {
|
|
if (l.datalen + n > l.datacap) {
|
|
let nc: u64 = l.datacap;
|
|
if (nc == 0u64) { nc = 256u64; };
|
|
for (nc < l.datalen + n) { nc = nc * 2u64; };
|
|
let nb: *u8 = rt.malloc(nc): *u8;
|
|
let i: u64 = 0u64;
|
|
for (i < l.datalen) {
|
|
nb[i] = l.data[i];
|
|
i += 1u64;
|
|
};
|
|
l.data = nb;
|
|
l.datacap = nc;
|
|
};
|
|
let i: u64 = 0u64;
|
|
for (i < n) {
|
|
l.data[l.datalen + i] = src[i];
|
|
i += 1u64;
|
|
};
|
|
l.datalen += n;
|
|
};
|
|
|
|
// ---- C-string helpers --------------------------------------------------
|
|
|
|
fn cstrlen(p: *u8) u64 = {
|
|
let n: u64 = 0u64;
|
|
for (p[n] != 0u8) { n += 1u64; };
|
|
return n;
|
|
};
|
|
|
|
// pathstr — view a NUL-terminated *u8 as a str. Bridges argv/arena
|
|
// callers to lib/os entrypoints (str post-task-#23). Shared with
|
|
// main.ww and dyn.ww via the w6l bundle.
|
|
fn pathstr(p: *u8) str = {
|
|
let r: str;
|
|
r.ptr = p;
|
|
r.len = cstrlen(p): i32;
|
|
return r;
|
|
};
|
|
|
|
fn cstreq(p: *u8, lit: str) bool = {
|
|
let n: u64 = lit.len: u64;
|
|
let i: u64 = 0u64;
|
|
for (i < n) {
|
|
let li: i32 = i: i32;
|
|
if (p[i] != lit[li]) { return false; };
|
|
i += 1u64;
|
|
};
|
|
if (p[i] != 0u8) { return false; };
|
|
return true;
|
|
};
|
|
|
|
// Build a ww str from a NUL-terminated *u8 (for passing to intern).
|
|
fn cstrtostr(a: *arena, p: *u8) str = {
|
|
let n: u64 = cstrlen(p);
|
|
return astrndup(a, p, n);
|
|
};
|
|
|
|
// ---- archive (SysV ar) types and helpers -------------------------------
|
|
//
|
|
// Each archive member starts with a 60-byte ar_hdr. The fields we care
|
|
// about are the first byte (member type) and the size at offset 48 (a
|
|
// 10-byte, space-padded decimal). Member bodies are 2-byte aligned.
|
|
|
|
type defent = struct {
|
|
name: str,
|
|
dnext: *defent,
|
|
};
|
|
|
|
type armember = struct {
|
|
data: *u8, // arena copy of the member's ELF bytes
|
|
size: u64,
|
|
defs: *defent, // linked list of defined globals
|
|
loaded: i32,
|
|
mnext: *armember,
|
|
};
|
|
|
|
fn isarchive(p: *u8, len: u64) bool = {
|
|
if (len < 8u64) { return false; };
|
|
if (p[0u64] != 33u8) { return false; }; // '!'
|
|
if (p[1u64] != 60u8) { return false; }; // '<'
|
|
if (p[2u64] != 97u8) { return false; }; // 'a'
|
|
if (p[3u64] != 114u8) { return false; }; // 'r'
|
|
if (p[4u64] != 99u8) { return false; }; // 'c'
|
|
if (p[5u64] != 104u8) { return false; }; // 'h'
|
|
if (p[6u64] != 62u8) { return false; }; // '>'
|
|
if (p[7u64] != 10u8) { return false; }; // '\n'
|
|
return true;
|
|
};
|
|
|
|
// arfield — parse a space-padded decimal integer of width n.
|
|
fn arfield(p: *u8, n: u64) u64 = {
|
|
let v: u64 = 0u64;
|
|
let i: u64 = 0u64;
|
|
for (i < n) {
|
|
let c: u8 = p[i];
|
|
if (c < 48u8) { return v; }; // space, NUL, etc.
|
|
if (c > 57u8) { return v; };
|
|
v = v * 10u64 + ((c - 48u8): u64);
|
|
i += 1u64;
|
|
};
|
|
return v;
|
|
};
|
|
|
|
// elfglobals — return a linked list of names of globally-defined
|
|
// (STB_GLOBAL) symbols whose section is `.text`. Names are arena
|
|
// copies, so the source ELF buffer can be freed afterward.
|
|
fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = {
|
|
if (len < EHDR_SIZE) { return nil; };
|
|
if (buf[0u64] != 127u8) { return nil; };
|
|
if (buf[1u64] != 69u8) { return nil; };
|
|
if (buf[2u64] != 76u8) { return nil; };
|
|
if (buf[3u64] != 70u8) { return nil; };
|
|
|
|
let shoff: u64 = rdu64(buf, EHDR_SHOFF);
|
|
let shnum: u32 = rdu16(buf, EHDR_SHNUM): u32;
|
|
let shstrndx: u32 = rdu16(buf, EHDR_SHSTRNDX): u32;
|
|
|
|
let shstrshoff: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
|
|
let shstr: *u8 = buf + shstrshoff;
|
|
|
|
let idxtext: i32 = -1;
|
|
let idxdata: i32 = -1;
|
|
let idxsymtab: i32 = -1;
|
|
let i: u32 = 0u32;
|
|
for (i < shnum) {
|
|
let secoff: u64 = shoff + (i: u64) * SHDR_SIZE;
|
|
let shtype: u32 = rdu32(buf, secoff + SHDR_TYPE);
|
|
let shname: u32 = rdu32(buf, secoff + SHDR_NAME);
|
|
let nm: *u8 = shstr + (shname: u64);
|
|
if (shtype == SHT_PROGBITS: u32) {
|
|
if (cstreq(nm, ".text")) { idxtext = i: i32; };
|
|
if (cstreq(nm, ".data")) { idxdata = i: i32; };
|
|
};
|
|
if (shtype == SHT_SYMTAB: u32) { idxsymtab = i: i32; };
|
|
i += 1u32;
|
|
};
|
|
if (idxtext < 0) { return nil; };
|
|
if (idxsymtab < 0) { return nil; };
|
|
|
|
let symsh: u64 = shoff + (idxsymtab: u64) * SHDR_SIZE;
|
|
let symoff: u64 = rdu64(buf, symsh + SHDR_OFFSET);
|
|
let symsize: u64 = rdu64(buf, symsh + SHDR_SIZE_F);
|
|
let symlink: u32 = rdu32(buf, symsh + SHDR_LINK);
|
|
let nsyms: u64 = symsize / SYM_SIZE;
|
|
|
|
let strsh: u64 = shoff + (symlink: u64) * SHDR_SIZE;
|
|
let stroff: u64 = rdu64(buf, strsh + SHDR_OFFSET);
|
|
let strtab: *u8 = buf + stroff;
|
|
|
|
let head: *defent = nil;
|
|
let si: u64 = 1u64;
|
|
for (si < nsyms) {
|
|
let symp: u64 = symoff + si * SYM_SIZE;
|
|
let stname: u32 = rdu32(buf, symp + SYM_NAME);
|
|
let stinfo: u8 = buf[symp + SYM_INFO];
|
|
let stshndx: u16 = rdu16(buf, symp + SYM_SHNDX);
|
|
let bind: u32 = (stinfo: u32) >> 4u32;
|
|
// STB_GLOBAL = 1; defined in .text or .data. Both are
|
|
// included so an archive member that owns a data global
|
|
// gets pulled in when something references it.
|
|
if (bind == 1u32) {
|
|
if (stshndx != 0u16) {
|
|
let intext: bool = (stshndx: i32) == idxtext;
|
|
let indt: bool = false;
|
|
if (idxdata >= 0) {
|
|
indt = (stshndx: i32) == idxdata;
|
|
};
|
|
if (intext || indt) {
|
|
let nmp: *u8 = strtab + (stname: u64);
|
|
if (nmp[0u64] != 0u8) {
|
|
let nm: str = cstrtostr(a, nmp);
|
|
let de: *defent = alloc(defent { name = nm, dnext = head })!;
|
|
head = de;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
si += 1u64;
|
|
};
|
|
return head;
|
|
};
|
|
|
|
// memberdefinesundef — true if any of m's defined globals matches a
|
|
// currently-undefined symbol in the linker's symbol table. Names not
|
|
// already interned are uninteresting (the link doesn't need them yet).
|
|
fn memberdefinesundef(l: *lnk, m: *armember) bool = {
|
|
let de: *defent = m.defs;
|
|
for (de != nil) {
|
|
let s: *lsym = lookup(l, de.name);
|
|
if (s != nil) {
|
|
if (s.defined == 0) { return true; };
|
|
};
|
|
de = de.dnext;
|
|
};
|
|
return false;
|
|
};
|
|
|
|
// loadarchive — port of cmd/w6l/obj.c:load_archive.
|
|
//
|
|
// Pass 1 indexes every regular member. Pass 2 iteratively pulls in any
|
|
// member that supplies a currently-undefined symbol; each pull may
|
|
// introduce fresh undefs, so we loop until quiescent.
|
|
fn loadarchive(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = {
|
|
let head: *armember = nil;
|
|
let tail: *armember = nil;
|
|
let pos: u64 = 8u64; // past "!<arch>\n"
|
|
for (pos + 60u64 <= len) {
|
|
let hdrsize: u64 = arfield(buf + pos + 48u64, 10u64);
|
|
let hdrend: u64 = pos + 60u64;
|
|
if (hdrend + hdrsize > len) { break; };
|
|
let first: u8 = buf[pos];
|
|
// Skip the symbol table ('/'), long-name table ('//'), and
|
|
// any padding entries (NUL or space leading byte).
|
|
if (first != 47u8) { if (first != 0u8) { if (first != 32u8) {
|
|
let m: *armember = alloc(armember { size = hdrsize })!;
|
|
let mb: *u8 = amalloc(l.a, hdrsize): *u8;
|
|
let i: u64 = 0u64;
|
|
for (i < hdrsize) {
|
|
mb[i] = buf[hdrend + i];
|
|
i += 1u64;
|
|
};
|
|
m.data = mb;
|
|
m.defs = elfglobals(l.a, mb, hdrsize);
|
|
if (head == nil) { head = m; }
|
|
else { tail.mnext = m; };
|
|
tail = m;
|
|
}; }; };
|
|
pos = hdrend + hdrsize;
|
|
if ((hdrsize & 1u64) != 0u64) { pos = pos + 1u64; };
|
|
};
|
|
|
|
let changed: i32 = 1;
|
|
for (changed != 0) {
|
|
changed = 0;
|
|
let m: *armember = head;
|
|
for (m != nil) {
|
|
if (m.loaded == 0) {
|
|
if (memberdefinesundef(l, m)) {
|
|
if (loadimage(l, path, m.data, m.size) == 0) {
|
|
m.loaded = 1;
|
|
changed = 1;
|
|
};
|
|
};
|
|
};
|
|
m = m.mnext;
|
|
};
|
|
};
|
|
return 0;
|
|
};
|
|
|
|
// ---- main loader -------------------------------------------------------
|
|
|
|
export fn load(l: *lnk, path: *u8) i32 = {
|
|
let bufp: *u8;
|
|
let buflen: u64;
|
|
bufp, buflen = slurp(path);
|
|
if (bufp == nil) {
|
|
os.write(2, "w6l: cannot read object\n".ptr, 23u64);
|
|
return -1;
|
|
};
|
|
if (isarchive(bufp, buflen)) {
|
|
return loadarchive(l, path, bufp, buflen);
|
|
};
|
|
return loadimage(l, path, bufp, buflen);
|
|
};
|
|
|
|
fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = {
|
|
if (len < EHDR_SIZE) { return -1; };
|
|
// magic: 0x7f, 'E', 'L', 'F'
|
|
if (buf[0u64] != 127u8) { return -1; };
|
|
if (buf[1u64] != 69u8) { return -1; };
|
|
if (buf[2u64] != 76u8) { return -1; };
|
|
if (buf[3u64] != 70u8) { return -1; };
|
|
if (buf[4u64] != 2u8) { return -1; }; // ELFCLASS64
|
|
if (rdu16(buf, EHDR_TYPE) != ET_REL: u16) { return -1; };
|
|
if (rdu16(buf, EHDR_MACHINE) != EM_X86_64: u16) { return -1; };
|
|
|
|
let shoff: u64 = rdu64(buf, EHDR_SHOFF);
|
|
let shnum: u32 = rdu16(buf, EHDR_SHNUM): u32;
|
|
let shstrndx: u32 = rdu16(buf, EHDR_SHSTRNDX): u32;
|
|
|
|
let shstrshoff: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
|
|
let shstr: *u8 = buf + shstrshoff;
|
|
|
|
// find .text, .data, .symtab, .rela.text, .rela.data
|
|
let idxtext: i32 = -1;
|
|
let idxdata: i32 = -1;
|
|
let idxsymtab: i32 = -1;
|
|
let idxrela: i32 = -1;
|
|
let idxrelad: i32 = -1;
|
|
let i: u32 = 0u32;
|
|
for (i < shnum) {
|
|
let secoff: u64 = shoff + (i: u64) * SHDR_SIZE;
|
|
let shtype: u32 = rdu32(buf, secoff + SHDR_TYPE);
|
|
let shname: u32 = rdu32(buf, secoff + SHDR_NAME);
|
|
let nm: *u8 = shstr + (shname: u64);
|
|
if (shtype == SHT_PROGBITS: u32) {
|
|
if (cstreq(nm, ".text")) { idxtext = i: i32; };
|
|
if (cstreq(nm, ".data")) { idxdata = i: i32; };
|
|
};
|
|
if (shtype == SHT_SYMTAB: u32) { idxsymtab = i: i32; };
|
|
if (shtype == SHT_RELA: u32) {
|
|
if (cstreq(nm, ".rela.text")) { idxrela = i: i32; };
|
|
if (cstreq(nm, ".rela.data")) { idxrelad = i: i32; };
|
|
};
|
|
i += 1u32;
|
|
};
|
|
if (idxtext < 0) {
|
|
os.write(2, "w6l: missing .text\n".ptr, 18u64);
|
|
return -1;
|
|
};
|
|
if (idxsymtab < 0) {
|
|
os.write(2, "w6l: missing .symtab\n".ptr, 20u64);
|
|
return -1;
|
|
};
|
|
|
|
let textsh: u64 = shoff + (idxtext: u64) * SHDR_SIZE;
|
|
let textoff: u64 = rdu64(buf, textsh + SHDR_OFFSET);
|
|
let textsize: u64 = rdu64(buf, textsh + SHDR_SIZE_F);
|
|
|
|
let symsh: u64 = shoff + (idxsymtab: u64) * SHDR_SIZE;
|
|
let symoff: u64 = rdu64(buf, symsh + SHDR_OFFSET);
|
|
let symsize: u64 = rdu64(buf, symsh + SHDR_SIZE_F);
|
|
let symlink: u32 = rdu32(buf, symsh + SHDR_LINK);
|
|
let nsyms: u64 = symsize / SYM_SIZE;
|
|
|
|
let strsh: u64 = shoff + (symlink: u64) * SHDR_SIZE;
|
|
let stroff: u64 = rdu64(buf, strsh + SHDR_OFFSET);
|
|
let strtab: *u8 = buf + stroff;
|
|
|
|
let datasize: u64 = 0u64;
|
|
let dataoff: u64 = 0u64;
|
|
if (idxdata >= 0) {
|
|
let datash: u64 = shoff + (idxdata: u64) * SHDR_SIZE;
|
|
dataoff = rdu64(buf, datash + SHDR_OFFSET);
|
|
datasize = rdu64(buf, datash + SHDR_SIZE_F);
|
|
};
|
|
|
|
// Track this object.
|
|
let ob: *lobj = alloc(lobj {
|
|
path = cstrtostr(l.a, path),
|
|
buf = buf,
|
|
len = len,
|
|
textoff = l.textlen,
|
|
textsize = textsize,
|
|
dataoff = l.datalen,
|
|
datasize = datasize,
|
|
onext = l.objs,
|
|
})!;
|
|
l.objs = ob;
|
|
|
|
// Append .text bytes to the combined image.
|
|
emittext(l, buf + textoff, textsize);
|
|
// Append .data bytes (if present) to the combined .data buffer.
|
|
if (idxdata >= 0) {
|
|
if (datasize > 0u64) {
|
|
emitdata(l, buf + dataoff, datasize);
|
|
};
|
|
};
|
|
|
|
// Walk symbols. We don't keep a per-object map[] of *lsym. Instead
|
|
// the reloc loop re-walks symtab and re-interns by name. Simpler
|
|
// than dancing around the cgen's u64-shift gaps.
|
|
let si: u64 = 1u64; // skip index 0 (always undef sentinel)
|
|
for (si < nsyms) {
|
|
let symp: u64 = symoff + si * SYM_SIZE;
|
|
let stname: u32 = rdu32(buf, symp + SYM_NAME);
|
|
let stshndx: u16 = rdu16(buf, symp + SYM_SHNDX);
|
|
let stvalue: u64 = rdu64(buf, symp + SYM_VALUE);
|
|
let nmp: *u8 = strtab + (stname: u64);
|
|
if (nmp[0u64] != 0u8) {
|
|
let nm: str = cstrtostr(l.a, nmp);
|
|
let gs: *lsym = intern(l, nm);
|
|
if (stshndx != 0u16) {
|
|
let intext: bool = (stshndx: i32) == idxtext;
|
|
let indt: bool = false;
|
|
if (idxdata >= 0) {
|
|
indt = (stshndx: i32) == idxdata;
|
|
};
|
|
if (intext) { if (indt) { indt = false; }; };
|
|
if (intext) {
|
|
if (gs.defined != 0) {
|
|
os.write(2, "w6l: duplicate symbol\n".ptr, 21u64);
|
|
l.errs += 1;
|
|
} else {
|
|
gs.defined = 1;
|
|
gs.owner = ob;
|
|
gs.idxinowner = si: i32;
|
|
gs.val = ob.textoff + stvalue;
|
|
};
|
|
};
|
|
if (indt) {
|
|
if (gs.defined != 0) {
|
|
os.write(2, "w6l: duplicate symbol\n".ptr, 21u64);
|
|
l.errs += 1;
|
|
} else {
|
|
gs.defined = 1;
|
|
gs.indata = 1;
|
|
gs.owner = ob;
|
|
gs.idxinowner = si: i32;
|
|
gs.val = ob.dataoff + stvalue;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
si += 1u64;
|
|
};
|
|
|
|
// Per-object relocation collection.
|
|
if (idxrela >= 0) {
|
|
let relash: u64 = shoff + (idxrela: u64) * SHDR_SIZE;
|
|
let relaoff: u64 = rdu64(buf, relash + SHDR_OFFSET);
|
|
let relasize: u64 = rdu64(buf, relash + SHDR_SIZE_F);
|
|
let nrel: u64 = relasize / RELA_SIZE;
|
|
let ri: u64 = 0u64;
|
|
for (ri < nrel) {
|
|
let rp: u64 = relaoff + ri * RELA_SIZE;
|
|
let roff: u64 = rdu64(buf, rp + RELA_OFFSET);
|
|
let rinfo: u64 = rdu64(buf, rp + RELA_INFO);
|
|
let raddend: u64 = rdu64(buf, rp + RELA_ADDEND);
|
|
let rsymidx: u32 = (rinfo >> 32u64): u32;
|
|
let rkind: i32 = ((rinfo & 4294967295u64): u32): i32;
|
|
let nr: *lrel = alloc(lrel {
|
|
off = ob.textoff + roff,
|
|
section = 0,
|
|
kind = rkind,
|
|
addend = raddend: i64,
|
|
rnext = l.rels,
|
|
})!;
|
|
// Look up the referenced sym by name (re-walk symtab).
|
|
if ((rsymidx: u64) < nsyms) {
|
|
let sp: u64 = symoff + (rsymidx: u64) * SYM_SIZE;
|
|
let sname: u32 = rdu32(buf, sp + SYM_NAME);
|
|
let snm: *u8 = strtab + (sname: u64);
|
|
if (snm[0u64] != 0u8) {
|
|
let nm: str = cstrtostr(l.a, snm);
|
|
nr.sym = intern(l, nm);
|
|
};
|
|
};
|
|
l.rels = nr;
|
|
ri += 1u64;
|
|
};
|
|
};
|
|
|
|
// Data-reloc collection. Offsets land in .data, shifted by
|
|
// this object's data_off so they index the combined buffer.
|
|
if (idxrelad >= 0) {
|
|
let relash: u64 = shoff + (idxrelad: u64) * SHDR_SIZE;
|
|
let relaoff: u64 = rdu64(buf, relash + SHDR_OFFSET);
|
|
let relasize: u64 = rdu64(buf, relash + SHDR_SIZE_F);
|
|
let nrel: u64 = relasize / RELA_SIZE;
|
|
let ri: u64 = 0u64;
|
|
for (ri < nrel) {
|
|
let rp: u64 = relaoff + ri * RELA_SIZE;
|
|
let roff: u64 = rdu64(buf, rp + RELA_OFFSET);
|
|
let rinfo: u64 = rdu64(buf, rp + RELA_INFO);
|
|
let raddend: u64 = rdu64(buf, rp + RELA_ADDEND);
|
|
let rsymidx: u32 = (rinfo >> 32u64): u32;
|
|
let rkind: i32 = ((rinfo & 4294967295u64): u32): i32;
|
|
let nr: *lrel = alloc(lrel {
|
|
off = ob.dataoff + roff,
|
|
section = 1,
|
|
kind = rkind,
|
|
addend = raddend: i64,
|
|
rnext = l.rels,
|
|
})!;
|
|
if ((rsymidx: u64) < nsyms) {
|
|
let sp: u64 = symoff + (rsymidx: u64) * SYM_SIZE;
|
|
let sname: u32 = rdu32(buf, sp + SYM_NAME);
|
|
let snm: *u8 = strtab + (sname: u64);
|
|
if (snm[0u64] != 0u8) {
|
|
let nm: str = cstrtostr(l.a, snm);
|
|
nr.sym = intern(l, nm);
|
|
};
|
|
};
|
|
l.rels = nr;
|
|
ri += 1u64;
|
|
};
|
|
};
|
|
|
|
return 0;
|
|
};
|
|
|
|
// selfhost/cmd/w6l/dyn.ww — port of cmd/w6l/dyn.c.
|
|
//
|
|
// Load a shared object (ET_DYN) so the linker knows which symbols it
|
|
// exports and which DT_NEEDED entry to record. We do not pull bytes
|
|
// from the .so; the dynamic loader maps it at runtime.
|
|
//
|
|
// Each call appends one lso to lnk->sos. l_so_provides_v answers
|
|
// "does this .so export the named symbol, and at which version?" —
|
|
// l_resolve uses that to promote unresolved references to dynamic.
|
|
|
|
package w6l;
|
|
|
|
import os;
|
|
import rt;
|
|
import mem;
|
|
import sym;
|
|
|
|
def ET_DYN_SO: u16 = 3u16;
|
|
def EM_X86_64_SO: u16 = 62u16;
|
|
|
|
def SHT_DYNAMIC: u32 = 6u32;
|
|
def SHT_DYNSYM: u32 = 11u32;
|
|
// GNU extensions, sh_type values.
|
|
def SHT_GNU_VERDEF: u32 = 1879048189u32; // 0x6ffffffd
|
|
def SHT_GNU_VERNEED: u32 = 1879048190u32; // 0x6ffffffe
|
|
def SHT_GNU_VERSYM: u32 = 1879048191u32; // 0x6fffffff
|
|
|
|
def DT_NULL_TAG: i64 = 0i64;
|
|
def DT_SONAME_TAG: i64 = 14i64;
|
|
|
|
// Versym special values.
|
|
def VER_NDX_LOCAL_C: u16 = 0u16;
|
|
def VER_NDX_GLOBAL_C: u16 = 1u16;
|
|
def VERSYM_HIDDEN_C: u16 = 32768u16; // 0x8000
|
|
def VERSYM_VERSION_C: u16 = 32767u16; // 0x7fff
|
|
|
|
// ELF64 ehdr field offsets (subset)
|
|
def EH_SHOFF: u64 = 40u64;
|
|
def EH_ETYPE: u64 = 16u64;
|
|
def EH_EMACHINE: u64 = 18u64;
|
|
def EH_SHENTSIZE: u64 = 58u64;
|
|
def EH_SHNUM: u64 = 60u64;
|
|
def EH_SHSTRNDX: u64 = 62u64;
|
|
|
|
// ELF64 Shdr (64 bytes)
|
|
def SH_SIZE: u64 = 64u64;
|
|
def SH_TYPE: u64 = 4u64;
|
|
def SH_OFFSET: u64 = 24u64;
|
|
def SH_SIZE_F: u64 = 32u64;
|
|
def SH_LINK: u64 = 40u64;
|
|
def SH_ENTSIZE: u64 = 56u64;
|
|
|
|
// ELF64 Sym (24 bytes)
|
|
def SY_SIZE: u64 = 24u64;
|
|
def SY_NAME: u64 = 0u64;
|
|
def SY_INFO: u64 = 4u64;
|
|
def SY_SHNDX: u64 = 6u64;
|
|
|
|
// ELF64 Dyn (16 bytes)
|
|
def DY_SIZE: u64 = 16u64;
|
|
def DY_TAG: u64 = 0u64;
|
|
def DY_VAL: u64 = 8u64;
|
|
|
|
// Verdef (20 bytes)
|
|
def VD_SIZE: u64 = 20u64;
|
|
def VD_NDX: u64 = 4u64;
|
|
def VD_CNT: u64 = 6u64;
|
|
def VD_AUX: u64 = 12u64;
|
|
def VD_NEXT: u64 = 16u64;
|
|
|
|
// Verdaux (8 bytes)
|
|
def VA_NAME: u64 = 0u64;
|
|
def VA_NEXT: u64 = 4u64;
|
|
|
|
// ---- little-endian byte readers ---------------------------------------
|
|
|
|
fn du16(p: *u8, off: u64) u16 = {
|
|
let b0: u16 = p[off]: u16;
|
|
let b1: u16 = p[off + 1u64]: u16;
|
|
return b0 | (b1 << 8u16);
|
|
};
|
|
|
|
fn du32(p: *u8, off: u64) u32 = {
|
|
let b0: u32 = p[off]: u32;
|
|
let b1: u32 = p[off + 1u64]: u32;
|
|
let b2: u32 = p[off + 2u64]: u32;
|
|
let b3: u32 = p[off + 3u64]: u32;
|
|
return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32);
|
|
};
|
|
|
|
fn du64(p: *u8, off: u64) u64 = {
|
|
let lo: u64 = du32(p, off): u64;
|
|
let hi: u64 = du32(p, off + 4u64): u64;
|
|
return lo | (hi << 32u64);
|
|
};
|
|
|
|
fn di64(p: *u8, off: u64) i64 = {
|
|
return du64(p, off): i64;
|
|
};
|
|
|
|
// ---- C-string helpers --------------------------------------------------
|
|
|
|
fn dcstrlen(p: *u8) u64 = {
|
|
let n: u64 = 0u64;
|
|
for (p[n] != 0u8) { n += 1u64; };
|
|
return n;
|
|
};
|
|
|
|
fn dcstrtostr(a: *arena, p: *u8) str = {
|
|
let n: u64 = dcstrlen(p);
|
|
return astrndup(a, p, n);
|
|
};
|
|
|
|
// basename: scan for last '/' and return pointer past it.
|
|
fn dbasename(p: *u8) *u8 = {
|
|
let n: u64 = dcstrlen(p);
|
|
let i: u64 = n;
|
|
for (i > 0u64) {
|
|
i -= 1u64;
|
|
if (p[i] == 47u8) { // '/'
|
|
return p + i + 1u64;
|
|
};
|
|
};
|
|
return p;
|
|
};
|
|
|
|
// ---- file slurp --------------------------------------------------------
|
|
|
|
fn slurpso(path: *u8) (*u8, u64) = {
|
|
let fd: i32 = os.open(pathstr(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 buf: *u8 = rt.malloc(n: u64): *u8;
|
|
let rr: (i64 | os.oserror) = os.readall(fd, buf, n: u64);
|
|
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; };
|
|
return buf, n: u64;
|
|
};
|
|
|
|
// ---- verdef helpers ----------------------------------------------------
|
|
|
|
// vdnameat — walk verdef records and return the name (as *u8 into
|
|
// the .so's verstr buffer) for the entry whose vd_ndx == ndx. The name
|
|
// is the first Verdaux's vda_name (subsequent auxes are predecessor
|
|
// names). Returns nil if no entry matches.
|
|
fn vdnameat(buf: *u8, verdefoff: u64, verdefsize: u64,
|
|
verstr: *u8, ndx: u16) *u8 = {
|
|
let off: u64 = 0u64;
|
|
for (off < verdefsize) {
|
|
let vdp: u64 = verdefoff + off;
|
|
let vdndx: u16 = du16(buf, vdp + VD_NDX);
|
|
let vdaux: u32 = du32(buf, vdp + VD_AUX);
|
|
let vdnext: u32 = du32(buf, vdp + VD_NEXT);
|
|
if (vdndx == ndx) {
|
|
let auxp: u64 = vdp + (vdaux: u64);
|
|
let vdaname: u32 = du32(buf, auxp + VA_NAME);
|
|
return verstr + (vdaname: u64);
|
|
};
|
|
if (vdnext == 0u32) { return nil; };
|
|
off += vdnext: u64;
|
|
};
|
|
return nil;
|
|
};
|
|
|
|
// ---- entry points ------------------------------------------------------
|
|
|
|
export fn loadso(l: *lnk, path: *u8) i32 = {
|
|
let buf: *u8;
|
|
let blen: u64;
|
|
buf, blen = slurpso(path);
|
|
if (buf == nil) {
|
|
os.write(2, "w6l: cannot read .so\n".ptr, 20u64);
|
|
return -1;
|
|
};
|
|
if (blen < 64u64) {
|
|
os.write(2, "w6l: short ELF\n".ptr, 14u64);
|
|
return -1;
|
|
};
|
|
if (buf[0u64] != 127u8) { return soerr("not ELF"); };
|
|
if (buf[1u64] != 69u8) { return soerr("not ELF"); };
|
|
if (buf[2u64] != 76u8) { return soerr("not ELF"); };
|
|
if (buf[3u64] != 70u8) { return soerr("not ELF"); };
|
|
if (buf[4u64] != 2u8) { return soerr("not ELFCLASS64"); };
|
|
if (du16(buf, EH_EMACHINE) != EM_X86_64_SO) {
|
|
return soerr("not amd64");
|
|
};
|
|
if (du16(buf, EH_ETYPE) != ET_DYN_SO) {
|
|
return soerr("not ET_DYN");
|
|
};
|
|
|
|
let shoff: u64 = du64(buf, EH_SHOFF);
|
|
let shnum: u32 = du16(buf, EH_SHNUM): u32;
|
|
if (shoff == 0u64) { return soerr("stripped .so unsupported"); };
|
|
if (shnum == 0u32) { return soerr("stripped .so unsupported"); };
|
|
|
|
// Locate the four sections we care about.
|
|
let idxdynsym: i32 = -1;
|
|
let idxdynamic: i32 = -1;
|
|
let idxversym: i32 = -1;
|
|
let idxverdef: i32 = -1;
|
|
let i: u32 = 0u32;
|
|
for (i < shnum) {
|
|
let shp: u64 = shoff + (i: u64) * SH_SIZE;
|
|
let shtype: u32 = du32(buf, shp + SH_TYPE);
|
|
if (shtype == SHT_DYNSYM) { idxdynsym = i: i32; };
|
|
if (shtype == SHT_DYNAMIC) { idxdynamic = i: i32; };
|
|
if (shtype == SHT_GNU_VERSYM) { idxversym = i: i32; };
|
|
if (shtype == SHT_GNU_VERDEF) { idxverdef = i: i32; };
|
|
i += 1u32;
|
|
};
|
|
if (idxdynsym < 0) {
|
|
return soerr("no .dynsym");
|
|
};
|
|
|
|
let dynsymsh: u64 = shoff + (idxdynsym: u64) * SH_SIZE;
|
|
let dynsymoff: u64 = du64(buf, dynsymsh + SH_OFFSET);
|
|
let dynsymsize: u64 = du64(buf, dynsymsh + SH_SIZE_F);
|
|
let dynsymlink: u32 = du32(buf, dynsymsh + SH_LINK);
|
|
let nsyms: u64 = dynsymsize / SY_SIZE;
|
|
|
|
let dynstrsh: u64 = shoff + (dynsymlink: u64) * SH_SIZE;
|
|
let dynstroff: u64 = du64(buf, dynstrsh + SH_OFFSET);
|
|
let dynstr: *u8 = buf + dynstroff;
|
|
|
|
// SONAME: .dynamic strings live in the section pointed at by its
|
|
// sh_link (almost always .dynstr).
|
|
let sonamecs: *u8 = nil;
|
|
if (idxdynamic >= 0) {
|
|
let dynsh: u64 = shoff + (idxdynamic: u64) * SH_SIZE;
|
|
let dynoff: u64 = du64(buf, dynsh + SH_OFFSET);
|
|
let dynsize: u64 = du64(buf, dynsh + SH_SIZE_F);
|
|
let dynlink: u32 = du32(buf, dynsh + SH_LINK);
|
|
let dstrsh: u64 = shoff + (dynlink: u64) * SH_SIZE;
|
|
let dstroff: u64 = du64(buf, dstrsh + SH_OFFSET);
|
|
let dstr: *u8 = buf + dstroff;
|
|
let nd: u64 = dynsize / DY_SIZE;
|
|
let di: u64 = 0u64;
|
|
for (di < nd) {
|
|
let dp: u64 = dynoff + di * DY_SIZE;
|
|
let dtag: i64 = di64(buf, dp + DY_TAG);
|
|
if (dtag == DT_NULL_TAG) {
|
|
di = nd; // break
|
|
} else {
|
|
if (dtag == DT_SONAME_TAG) {
|
|
let dval: u64 = du64(buf, dp + DY_VAL);
|
|
sonamecs = dstr + dval;
|
|
di = nd; // break
|
|
} else {
|
|
di += 1u64;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
if (sonamecs == nil) {
|
|
sonamecs = dbasename(path);
|
|
};
|
|
|
|
// Versym is one u16 per dynsym entry.
|
|
let versymoff: u64 = 0u64;
|
|
let hasversym: i32 = 0;
|
|
if (idxversym >= 0) {
|
|
let vssh: u64 = shoff + (idxversym: u64) * SH_SIZE;
|
|
versymoff = du64(buf, vssh + SH_OFFSET);
|
|
hasversym = 1;
|
|
};
|
|
|
|
// Verdef section bounds + the .dynstr-like string section it uses.
|
|
let verdefoff: u64 = 0u64;
|
|
let verdefsize: u64 = 0u64;
|
|
let verstr: *u8 = nil;
|
|
if (idxverdef >= 0) {
|
|
let vdsh: u64 = shoff + (idxverdef: u64) * SH_SIZE;
|
|
verdefoff = du64(buf, vdsh + SH_OFFSET);
|
|
verdefsize = du64(buf, vdsh + SH_SIZE_F);
|
|
let vdlink: u32 = du32(buf, vdsh + SH_LINK);
|
|
let vstrsh: u64 = shoff + (vdlink: u64) * SH_SIZE;
|
|
let vstroff: u64 = du64(buf, vstrsh + SH_OFFSET);
|
|
verstr = buf + vstroff;
|
|
};
|
|
|
|
// Build the lso. Exports are appended in dynsym order so
|
|
// soprovides_v's first-match semantics match the C version.
|
|
let so: *lso = alloc(lso { path = dcstrtostr(l.a, path), soname = dcstrtostr(l.a, sonamecs) })!;
|
|
let tail: *lexport = nil;
|
|
|
|
let si: u64 = 1u64;
|
|
for (si < nsyms) {
|
|
let sp: u64 = dynsymoff + si * SY_SIZE;
|
|
let stshndx: u16 = du16(buf, sp + SY_SHNDX);
|
|
if (stshndx == 0u16) { si += 1u64; } else {
|
|
let stinfo: u8 = buf[sp + SY_INFO];
|
|
let bind: u32 = (stinfo: u32) >> 4u32;
|
|
if (bind != 1u32) { if (bind != 2u32) {
|
|
// not GLOBAL/WEAK
|
|
si += 1u64;
|
|
continue;
|
|
}; };
|
|
let stname: u32 = du32(buf, sp + SY_NAME);
|
|
let nmp: *u8 = dynstr + (stname: u64);
|
|
if (nmp[0u64] == 0u8) {
|
|
si += 1u64;
|
|
continue;
|
|
};
|
|
|
|
// Determine version. Skip non-default (hidden) and
|
|
// local entries.
|
|
let vernamecs: *u8 = nil;
|
|
let keep: i32 = 1;
|
|
if (hasversym != 0) {
|
|
let v: u16 = du16(buf, versymoff + si * 2u64);
|
|
if ((v & VERSYM_HIDDEN_C) != 0u16) {
|
|
keep = 0; // non-default
|
|
} else {
|
|
let vidx: u16 = v & VERSYM_VERSION_C;
|
|
if (vidx == VER_NDX_LOCAL_C) {
|
|
keep = 0; // not exported
|
|
} else { if (vidx == VER_NDX_GLOBAL_C) {
|
|
vernamecs = nil;
|
|
} else { if (vidx == 1u16) {
|
|
// glibc's BASE entry: treat as
|
|
// unversioned. (The C version
|
|
// notes that vidx==1 in Verdef
|
|
// maps to the SONAME BASE.)
|
|
vernamecs = nil;
|
|
} else {
|
|
if (verstr != nil) {
|
|
let nm: *u8 = vdnameat(buf, verdefoff, verdefsize, verstr, vidx);
|
|
vernamecs = nm;
|
|
};
|
|
}; }; };
|
|
};
|
|
};
|
|
|
|
if (keep != 0) {
|
|
let e: *lexport = alloc(lexport { name = dcstrtostr(l.a, nmp) })!;
|
|
if (vernamecs != nil) {
|
|
e.version = dcstrtostr(l.a, vernamecs);
|
|
};
|
|
if (tail == nil) {
|
|
so.exports = e;
|
|
} else {
|
|
tail.enext = e;
|
|
};
|
|
tail = e;
|
|
};
|
|
si += 1u64;
|
|
};
|
|
};
|
|
|
|
so.sonext = l.sos;
|
|
l.sos = so;
|
|
return 0;
|
|
};
|
|
|
|
fn soerr(msg: str) i32 = {
|
|
os.write(2, "w6l: ".ptr, 4u64);
|
|
os.write(2, msg.ptr, msg.len: u64);
|
|
os.write(2, "\n".ptr, 1u64);
|
|
return -1;
|
|
};
|
|
|
|
// soprovides — 1 if so exports name, 0 otherwise.
|
|
export fn soprovides(so: *lso, name: str) i32 = {
|
|
if (so == nil) { return 0; };
|
|
let e: *lexport = so.exports;
|
|
for (e != nil) {
|
|
if (streq(e.name, name)) { return 1; };
|
|
e = e.enext;
|
|
};
|
|
return 0;
|
|
};
|
|
|
|
// soversion — the version of so's export named `name`, or an empty
|
|
// str (ptr=nil, len=0) if the export is unversioned or not present.
|
|
export fn soversion(so: *lso, name: str) str = {
|
|
let result: str;
|
|
result.ptr = nil;
|
|
result.len = 0i32;
|
|
if (so == nil) { return result; };
|
|
let e: *lexport = so.exports;
|
|
for (e != nil) {
|
|
if (streq(e.name, name)) {
|
|
result.ptr = e.version.ptr;
|
|
result.len = e.version.len;
|
|
return result;
|
|
};
|
|
e = e.enext;
|
|
};
|
|
return result;
|
|
};
|
|
|
|
// `streq` lives in sym.ww — same bundle, single definition.
|
|
|
|
// selfhost/cmd/w6l/pass.ww — port of cmd/w6l/pass.c.
|
|
//
|
|
// Resolution + relocation. l_resolve flags every undefined symbol
|
|
// referenced by a relocation, and promotes those provided by some
|
|
// loaded .so to "dynamic" with a freshly-assigned PLT slot.
|
|
// l_relocate walks the rel list and patches the .text bytes in place
|
|
// once the final virtual base is known. Dynamic refs are deferred:
|
|
// their site is patched later in dynout, once the PLT vaddr is known.
|
|
//
|
|
// Supported relocation kinds: PC32 (=2), PLT32 (=4); both are 32-bit
|
|
// PC-relative displacements (PLT32 == PC32 for static).
|
|
|
|
package w6l;
|
|
|
|
import os;
|
|
import sym;
|
|
import dyn;
|
|
|
|
def R_X86_64_64: i32 = 1;
|
|
def R_X86_64_PC32: i32 = 2;
|
|
def R_X86_64_PLT32: i32 = 4;
|
|
|
|
export fn resolve(l: *lnk) i32 = {
|
|
// Initialise dynamic-linking sentinels. amalloc zeroes, so
|
|
// isdyn/dynlib start clean — but pltidx and dynsymidx
|
|
// must be -1, not 0.
|
|
let si: *lsym = l.syms;
|
|
for (si != nil) {
|
|
si.pltidx = -1;
|
|
si.dynsymidx = -1;
|
|
si = si.snext;
|
|
};
|
|
|
|
// Promote each undefined sym that some lso exports to dynamic
|
|
// and hand it a PLT slot. Iteration order over the relocation
|
|
// list determines slot numbering and is stable across runs.
|
|
let r: *lrel = l.rels;
|
|
for (r != nil) {
|
|
if (r.sym != nil) {
|
|
if (r.sym.defined == 0) {
|
|
if (r.sym.isdyn == 0) {
|
|
let so: *lso = l.sos;
|
|
for (so != nil) {
|
|
if (soprovides(so, r.sym.name) != 0) {
|
|
r.sym.isdyn = 1;
|
|
r.sym.dynlib = so;
|
|
r.sym.pltidx = l.dynn;
|
|
l.dynn += 1;
|
|
so = nil; // break
|
|
} else {
|
|
so = so.sonext;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
r = r.rnext;
|
|
};
|
|
|
|
// What remains undefined truly is undefined.
|
|
let r2: *lrel = l.rels;
|
|
for (r2 != nil) {
|
|
if (r2.sym != nil) {
|
|
if (r2.sym.defined == 0) {
|
|
if (r2.sym.isdyn == 0) {
|
|
os.write(2, "w6l: undefined reference to '".ptr, 28u64);
|
|
let nm: str = r2.sym.name;
|
|
os.write(2, nm.ptr, nm.len: u64);
|
|
os.write(2, "'\n".ptr, 2u64);
|
|
l.errs += 1;
|
|
};
|
|
};
|
|
};
|
|
r2 = r2.rnext;
|
|
};
|
|
return l.errs;
|
|
};
|
|
|
|
fn patchu32(p: *u8, v: u32) void = {
|
|
p[0] = (v & 255u32): u8;
|
|
p[1] = ((v >> 8u32) & 255u32): u8;
|
|
p[2] = ((v >> 16u32) & 255u32): u8;
|
|
p[3] = ((v >> 24u32) & 255u32): u8;
|
|
};
|
|
|
|
fn patchu64(p: *u8, v: u64) void = {
|
|
let i: i32 = 0;
|
|
for (i < 8) {
|
|
p[i] = ((v >> (i: u64 * 8u64)) & 255u64): u8;
|
|
i += 1;
|
|
};
|
|
};
|
|
|
|
export fn relocate(l: *lnk, textva: u64, datava: u64) i32 = {
|
|
let r: *lrel = l.rels;
|
|
for (r != nil) {
|
|
if (r.sym != nil) {
|
|
// Dynamic refs are patched later in dynout once the
|
|
// PLT vaddr is known.
|
|
if (r.sym.isdyn != 0) {
|
|
r = r.rnext;
|
|
continue;
|
|
};
|
|
if (r.sym.defined != 0) {
|
|
let symva: u64 = textva + r.sym.val;
|
|
if (r.sym.indata != 0) { symva = datava + r.sym.val; };
|
|
let k: i32 = r.kind;
|
|
if (k == R_X86_64_PC32) {
|
|
let site: u64 = textva + r.off;
|
|
let rel: i64 = (symva: i64 - site: i64) + r.addend;
|
|
patchu32(l.text + r.off, rel: u32);
|
|
} else { if (k == R_X86_64_PLT32) {
|
|
let site: u64 = textva + r.off;
|
|
let rel: i64 = (symva: i64 - site: i64) + r.addend;
|
|
patchu32(l.text + r.off, rel: u32);
|
|
} else { if (k == R_X86_64_64) {
|
|
// Absolute 64-bit. Currently used only
|
|
// for DATAR slots in .data.
|
|
let v: u64 = (symva: i64 + r.addend): u64;
|
|
if (r.section == 1) {
|
|
patchu64(l.data + r.off, v);
|
|
} else {
|
|
patchu64(l.text + r.off, v);
|
|
};
|
|
} else {
|
|
os.write(2, "w6l: unsupported reloc kind\n".ptr, 27u64);
|
|
l.errs += 1;
|
|
};};};
|
|
};
|
|
};
|
|
r = r.rnext;
|
|
};
|
|
return l.errs;
|
|
};
|
|
|
|
// selfhost/cmd/w6l/dynout.ww — port of cmd/w6l/dynout.c.
|
|
//
|
|
// Emit a dynamic-linked ELF executable. The shape is the simplest
|
|
// valid one: PT_INTERP + PT_DYNAMIC + DT_BIND_NOW so the loader
|
|
// resolves every PLT slot at startup (no lazy binding, no PLT0
|
|
// trampoline). SysV .hash, not .gnu.hash. Non-PIE, fixed base.
|
|
//
|
|
// Layout:
|
|
// [0] Ehdr
|
|
// [64] Phdrs (PT_LOAD R+X, PT_LOAD R+W, PT_INTERP, PT_DYNAMIC)
|
|
// [interp_off] "/lib64/ld-linux-x86-64.so.2\0"
|
|
// [dynstr_off] .dynstr
|
|
// [dynsym_off] .dynsym
|
|
// [hash_off] .hash
|
|
// [versym_off] .gnu.version
|
|
// [verneed_off] .gnu.version_r
|
|
// [relaplt_off] .rela.plt
|
|
// [pad to 0x1000]
|
|
// [text_off] .text
|
|
// [plt_off] .plt
|
|
// [pad to next page]
|
|
// [gotplt_off] .got.plt (writable; mapped by PT_LOAD #2)
|
|
// [dynamic_off] .dynamic (writable; covered by PT_DYNAMIC)
|
|
|
|
package w6l;
|
|
|
|
import os;
|
|
import rt;
|
|
import mem;
|
|
import sym;
|
|
|
|
// ELF constants
|
|
def ET_EXEC_D: u16 = 2u16;
|
|
def EM_X86_64_D: u16 = 62u16;
|
|
def EV_CURRENT_D: u32 = 1u32;
|
|
def ELFCLASS64_D: u8 = 2u8;
|
|
def ELFDATA2LSB_D: u8 = 1u8;
|
|
|
|
def PT_LOAD_D: u32 = 1u32;
|
|
def PT_DYNAMIC_D: u32 = 2u32;
|
|
def PT_INTERP_D: u32 = 3u32;
|
|
def PF_X_D: u32 = 1u32;
|
|
def PF_W_D: u32 = 2u32;
|
|
def PF_R_D: u32 = 4u32;
|
|
|
|
def DT_NULL: i64 = 0i64;
|
|
def DT_NEEDED: i64 = 1i64;
|
|
def DT_PLTRELSZ: i64 = 2i64;
|
|
def DT_PLTGOT: i64 = 3i64;
|
|
def DT_HASH: i64 = 4i64;
|
|
def DT_STRTAB: i64 = 5i64;
|
|
def DT_SYMTAB: i64 = 6i64;
|
|
def DT_STRSZ: i64 = 10i64;
|
|
def DT_SYMENT: i64 = 11i64;
|
|
def DT_PLTREL: i64 = 20i64;
|
|
def DT_RELA: i64 = 7i64;
|
|
def DT_JMPREL: i64 = 23i64;
|
|
def DT_BIND_NOW: i64 = 24i64;
|
|
def DT_VERSYM: i64 = 1879048176i64; // 0x6ffffff0
|
|
def DT_VERNEED: i64 = 1879048190i64; // 0x6ffffffe
|
|
def DT_VERNEEDNUM: i64 = 1879048191i64; // 0x6fffffff
|
|
|
|
def VER_NDX_LOCAL_D: u16 = 0u16;
|
|
def VER_NDX_GLOBAL_D: u16 = 1u16;
|
|
|
|
def R_X86_64_PC32_D: i32 = 2;
|
|
def R_X86_64_PLT32_D: i32 = 4;
|
|
def R_X86_64_JUMP_SLOT_D: u32 = 7u32;
|
|
|
|
def STB_GLOBAL_D: u8 = 1u8;
|
|
def STT_FUNC_D: u8 = 2u8;
|
|
|
|
def PLT_STUB_BYTES_D: u64 = 8u64;
|
|
def PAGE: u64 = 4096u64;
|
|
|
|
def INTERP: str = "/lib64/ld-linux-x86-64.so.2";
|
|
|
|
// ---- byte writers ------------------------------------------------------
|
|
|
|
fn dwr8(buf: *u8, off: u64, v: u8) void = {
|
|
buf[off] = v;
|
|
};
|
|
|
|
fn dwr16(buf: *u8, off: u64, v: u16) void = {
|
|
buf[off] = (v & 255u16): u8;
|
|
buf[off + 1u64] = ((v >> 8u16) & 255u16): u8;
|
|
};
|
|
|
|
fn dwr32(buf: *u8, off: u64, v: u32) void = {
|
|
buf[off] = (v & 255u32): u8;
|
|
buf[off + 1u64] = ((v >> 8u32) & 255u32): u8;
|
|
buf[off + 2u64] = ((v >> 16u32) & 255u32): u8;
|
|
buf[off + 3u64] = ((v >> 24u32) & 255u32): u8;
|
|
};
|
|
|
|
fn dwr64(buf: *u8, off: u64, v: u64) void = {
|
|
dwr32(buf, off, (v & 4294967295u64): u32);
|
|
dwr32(buf, off + 4u64, ((v >> 32u64) & 4294967295u64): u32);
|
|
};
|
|
|
|
fn dwri64(buf: *u8, off: u64, v: i64) void = {
|
|
dwr64(buf, off, v: u64);
|
|
};
|
|
|
|
fn dwri32(buf: *u8, off: u64, v: i32) void = {
|
|
dwr32(buf, off, v: u32);
|
|
};
|
|
|
|
// ---- byte readers ------------------------------------------------------
|
|
|
|
fn drdu16(p: *u8, off: u64) u16 = {
|
|
let b0: u16 = p[off]: u16;
|
|
let b1: u16 = p[off + 1u64]: u16;
|
|
return b0 | (b1 << 8u16);
|
|
};
|
|
|
|
fn drdu32(p: *u8, off: u64) u32 = {
|
|
let b0: u32 = p[off]: u32;
|
|
let b1: u32 = p[off + 1u64]: u32;
|
|
let b2: u32 = p[off + 2u64]: u32;
|
|
let b3: u32 = p[off + 3u64]: u32;
|
|
return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32);
|
|
};
|
|
|
|
fn drdi32(p: *u8, off: u64) i32 = {
|
|
return drdu32(p, off): i32;
|
|
};
|
|
|
|
fn dbcopy(dst: *u8, off: u64, src: *u8, n: u64) void = {
|
|
let i: u64 = 0u64;
|
|
for (i < n) {
|
|
dst[off + i] = src[i];
|
|
i += 1u64;
|
|
};
|
|
};
|
|
|
|
// elfhash — SysV ELF hash. Used for .gnu.version_r's vna_hash.
|
|
fn elfhash(name: str) u32 = {
|
|
let h: u32 = 0u32;
|
|
let i: i32 = 0;
|
|
for (i < name.len) {
|
|
let c: u32 = (name[i]: u8): u32;
|
|
h = (h << 4u32) + c;
|
|
let g: u32 = h & 4026531840u32; // 0xf0000000
|
|
if (g != 0u32) { h = h ^ (g >> 24u32); };
|
|
h = h & ~g;
|
|
i += 1;
|
|
};
|
|
return h;
|
|
};
|
|
|
|
fn alignup(off: u64, a: u64) u64 = {
|
|
return (off + a - 1u64) & ~(a - 1u64);
|
|
};
|
|
|
|
fn streqd(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;
|
|
};
|
|
|
|
// ---- main entry --------------------------------------------------------
|
|
|
|
export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = {
|
|
// .data shares the R+W PT_LOAD with .got.plt and .dynamic.
|
|
// Placed after .dynamic so the segment is one contiguous run;
|
|
// relocate runs from here so the dyn layout's datava lands in
|
|
// patched offsets.
|
|
let a: *arena = l.a;
|
|
let n: i32 = l.dynn;
|
|
let nu: u64 = n: u64;
|
|
|
|
// ---- collect dyn syms into a plt_idx-indexed array ----
|
|
let dynsyms: **lsym = amalloc(a, nu * 8u64): **lsym;
|
|
let s: *lsym = l.syms;
|
|
for (s != nil) {
|
|
if (s.isdyn != 0) {
|
|
if (s.pltidx >= 0) {
|
|
if (s.pltidx < n) {
|
|
dynsyms[s.pltidx] = s;
|
|
};
|
|
};
|
|
};
|
|
s = s.snext;
|
|
};
|
|
let i: i32 = 0;
|
|
for (i < n) {
|
|
if (dynsyms[i] == nil) {
|
|
os.write(2, "w6l: dynout: no sym for plt_idx\n".ptr, 31u64);
|
|
return 1;
|
|
};
|
|
i += 1;
|
|
};
|
|
|
|
// ---- collect used .so's (in l.sos order) ----
|
|
let maxsos: i32 = 0;
|
|
let so: *lso = l.sos;
|
|
for (so != nil) { maxsos += 1; so = so.sonext; };
|
|
let sosused: **lso = amalloc(a, (maxsos: u64) * 8u64): **lso;
|
|
let nsos: i32 = 0;
|
|
so = l.sos;
|
|
for (so != nil) {
|
|
let used: i32 = 0;
|
|
let j: i32 = 0;
|
|
for (j < n) {
|
|
let dsm: *lsym = dynsyms[j];
|
|
let dl: *lso = dsm.dynlib;
|
|
if (dl == so) { used = 1; j = n; }
|
|
else { j += 1; };
|
|
};
|
|
if (used != 0) {
|
|
sosused[nsos] = so;
|
|
nsos += 1;
|
|
};
|
|
so = so.sonext;
|
|
};
|
|
|
|
// ---- build flat version table grouped by vlib ----
|
|
// vlib_sos_idx[k] = sos_used index for vlib k.
|
|
// vlib_first[k] = ver index of first version under vlib k.
|
|
// vlib_count[k] = number of versions under vlib k.
|
|
// ver_lib_idx[v] = vlib index that version v belongs to.
|
|
// ver_name_ptr_arr[v] = name's *u8 (interned in the .so's verdef strings).
|
|
// ver_name_len_buf[v] = name length (i32).
|
|
// ver_dynstr_off[v] = offset within .dynstr (assigned after layout).
|
|
// ver_vna_other[v] = versym index (starting at 2).
|
|
|
|
let vlibsosidxbuf: *u8 = amalloc(a, (maxsos: u64) * 4u64): *u8;
|
|
let vlibfirstbuf: *u8 = amalloc(a, (maxsos: u64) * 4u64): *u8;
|
|
let vlibcountbuf: *u8 = amalloc(a, (maxsos: u64) * 4u64): *u8;
|
|
let nvlibs: i32 = 0;
|
|
|
|
let verlibidxbuf: *u8 = amalloc(a, nu * 4u64): *u8;
|
|
let vernameptrarr: **u8 = amalloc(a, nu * 8u64): **u8;
|
|
let vernamelenbuf: *u8 = amalloc(a, nu * 4u64): *u8;
|
|
let verdynstroff: *u8 = amalloc(a, nu * 4u64): *u8;
|
|
let vervnaother: *u8 = amalloc(a, nu * 2u64): *u8;
|
|
let nvers: i32 = 0;
|
|
|
|
let si: i32 = 0;
|
|
for (si < nsos) {
|
|
let curso: *lso = sosused[si];
|
|
let has: i32 = 0;
|
|
let j: i32 = 0;
|
|
for (j < n) {
|
|
let dsm: *lsym = dynsyms[j];
|
|
let dl: *lso = dsm.dynlib;
|
|
if (dl == curso) {
|
|
let nm0: str = dsm.name;
|
|
let dv: str = soversion(curso, nm0);
|
|
if (dv.len > 0) {
|
|
has = 1; j = n;
|
|
} else { j += 1; };
|
|
} else { j += 1; };
|
|
};
|
|
if (has != 0) {
|
|
dwr32(vlibsosidxbuf, (nvlibs: u64) * 4u64, si: u32);
|
|
dwr32(vlibfirstbuf, (nvlibs: u64) * 4u64, nvers: u32);
|
|
let added: i32 = 0;
|
|
let jj: i32 = 0;
|
|
for (jj < n) {
|
|
let dsm2: *lsym = dynsyms[jj];
|
|
let dl2: *lso = dsm2.dynlib;
|
|
if (dl2 == curso) {
|
|
let nm2: str = dsm2.name;
|
|
let vname: str = soversion(curso, nm2);
|
|
if (vname.len > 0) {
|
|
let seen: i32 = 0;
|
|
let k: i32 = 0;
|
|
for (k < added) {
|
|
let kk: i32 = nvers - added + k;
|
|
let existing: str;
|
|
existing.ptr = vernameptrarr[kk];
|
|
existing.len = drdi32(vernamelenbuf, (kk: u64) * 4u64);
|
|
if (streqd(existing, vname)) {
|
|
seen = 1; k = added;
|
|
} else { k += 1; };
|
|
};
|
|
if (seen == 0) {
|
|
dwr32(verlibidxbuf, (nvers: u64) * 4u64, nvlibs: u32);
|
|
vernameptrarr[nvers] = vname.ptr;
|
|
dwri32(vernamelenbuf, (nvers: u64) * 4u64, vname.len);
|
|
nvers += 1;
|
|
added += 1;
|
|
};
|
|
};
|
|
};
|
|
jj += 1;
|
|
};
|
|
dwr32(vlibcountbuf, (nvlibs: u64) * 4u64, added: u32);
|
|
nvlibs += 1;
|
|
};
|
|
si += 1;
|
|
};
|
|
|
|
// Assign vna_other indices starting at 2, walking vlib then per-version.
|
|
let nextvna: u16 = 2u16;
|
|
let vi: i32 = 0;
|
|
for (vi < nvlibs) {
|
|
let first: i32 = drdi32(vlibfirstbuf, (vi: u64) * 4u64);
|
|
let cnt: i32 = drdi32(vlibcountbuf, (vi: u64) * 4u64);
|
|
let k: i32 = 0;
|
|
for (k < cnt) {
|
|
dwr16(vervnaother, ((first + k): u64) * 2u64, nextvna);
|
|
nextvna += 1u16;
|
|
k += 1;
|
|
};
|
|
vi += 1;
|
|
};
|
|
|
|
// ---- compute dynstr size ----
|
|
let dynstrsz: u64 = 1u64; // leading NUL
|
|
let pi: i32 = 0;
|
|
for (pi < nsos) {
|
|
let so4: *lso = sosused[pi];
|
|
dynstrsz += so4.soname.len: u64;
|
|
dynstrsz += 1u64;
|
|
pi += 1;
|
|
};
|
|
pi = 0;
|
|
for (pi < n) {
|
|
let dsm4: *lsym = dynsyms[pi];
|
|
dynstrsz += dsm4.name.len: u64;
|
|
dynstrsz += 1u64;
|
|
pi += 1;
|
|
};
|
|
pi = 0;
|
|
for (pi < nvers) {
|
|
let nmlen: i32 = drdi32(vernamelenbuf, (pi: u64) * 4u64);
|
|
dynstrsz += nmlen: u64;
|
|
dynstrsz += 1u64;
|
|
pi += 1;
|
|
};
|
|
|
|
// ---- fill dynstr ----
|
|
let dynstr: *u8 = amalloc(a, dynstrsz): *u8;
|
|
let dynstrpos: u64 = 1u64; // past leading NUL
|
|
|
|
let sonamestr: *u8 = amalloc(a, (nsos: u64) * 4u64): *u8;
|
|
pi = 0;
|
|
for (pi < nsos) {
|
|
dwr32(sonamestr, (pi: u64) * 4u64, dynstrpos: u32);
|
|
let so2: *lso = sosused[pi];
|
|
let snm: str = so2.soname;
|
|
dbcopy(dynstr, dynstrpos, snm.ptr, snm.len: u64);
|
|
dynstrpos += snm.len: u64;
|
|
dynstr[dynstrpos] = 0u8;
|
|
dynstrpos += 1u64;
|
|
pi += 1;
|
|
};
|
|
let symnamestr: *u8 = amalloc(a, nu * 4u64): *u8;
|
|
pi = 0;
|
|
for (pi < n) {
|
|
dwr32(symnamestr, (pi: u64) * 4u64, dynstrpos: u32);
|
|
let dsm: *lsym = dynsyms[pi];
|
|
let snm: str = dsm.name;
|
|
dbcopy(dynstr, dynstrpos, snm.ptr, snm.len: u64);
|
|
dynstrpos += snm.len: u64;
|
|
dynstr[dynstrpos] = 0u8;
|
|
dynstrpos += 1u64;
|
|
pi += 1;
|
|
};
|
|
pi = 0;
|
|
for (pi < nvers) {
|
|
dwr32(verdynstroff, (pi: u64) * 4u64, dynstrpos: u32);
|
|
let nmp: *u8 = vernameptrarr[pi];
|
|
let nmlen: i32 = drdi32(vernamelenbuf, (pi: u64) * 4u64);
|
|
dbcopy(dynstr, dynstrpos, nmp, nmlen: u64);
|
|
dynstrpos += nmlen: u64;
|
|
dynstr[dynstrpos] = 0u8;
|
|
dynstrpos += 1u64;
|
|
pi += 1;
|
|
};
|
|
|
|
// ---- per-dyn-sym versym index ----
|
|
let versymfor: *u8 = amalloc(a, nu * 2u64): *u8;
|
|
pi = 0;
|
|
for (pi < n) {
|
|
let dsm3: *lsym = dynsyms[pi];
|
|
let dl3: *lso = dsm3.dynlib;
|
|
let nm3: str = dsm3.name;
|
|
let vname: str = soversion(dl3, nm3);
|
|
if (vname.len == 0) {
|
|
dwr16(versymfor, (pi: u64) * 2u64, VER_NDX_GLOBAL_D);
|
|
} else {
|
|
let matched: i32 = 0;
|
|
let vk: i32 = 0;
|
|
for (vk < nvers) {
|
|
let vlx: i32 = drdi32(verlibidxbuf, (vk: u64) * 4u64);
|
|
let sosx: i32 = drdi32(vlibsosidxbuf, (vlx: u64) * 4u64);
|
|
if (sosused[sosx] == dl3) {
|
|
let exi: str;
|
|
exi.ptr = vernameptrarr[vk];
|
|
exi.len = drdi32(vernamelenbuf, (vk: u64) * 4u64);
|
|
if (streqd(exi, vname)) {
|
|
let other: u16 = drdu16(vervnaother, (vk: u64) * 2u64);
|
|
dwr16(versymfor, (pi: u64) * 2u64, other);
|
|
matched = 1;
|
|
vk = nvers;
|
|
} else { vk += 1; };
|
|
} else { vk += 1; };
|
|
};
|
|
if (matched == 0) {
|
|
dwr16(versymfor, (pi: u64) * 2u64, VER_NDX_GLOBAL_D);
|
|
};
|
|
};
|
|
pi += 1;
|
|
};
|
|
|
|
// ---- compute byte sizes ----
|
|
let ehdrsz: u64 = 64u64;
|
|
let nphdrs: u64 = 4u64;
|
|
let phdrsz: u64 = nphdrs * 56u64;
|
|
let interpsz: u64 = (INTERP.len: u64) + 1u64;
|
|
|
|
let nsymstotal: u64 = 1u64 + nu;
|
|
let dynsymsz: u64 = nsymstotal * 24u64;
|
|
|
|
let nbuckets: u32 = 1u32;
|
|
let nchain: u32 = nsymstotal: u32;
|
|
let hashsz: u64 = (2u64 + (nbuckets: u64) + (nchain: u64)) * 4u64;
|
|
|
|
let relapltsz: u64 = nu * 24u64;
|
|
let pltsz: u64 = nu * PLT_STUB_BYTES_D;
|
|
let gotpltsz: u64 = (3u64 + nu) * 8u64;
|
|
let versymsz: u64 = nsymstotal * 2u64;
|
|
|
|
let verneedsz: u64 = 0u64;
|
|
let vli: i32 = 0;
|
|
for (vli < nvlibs) {
|
|
let cnt: i32 = drdi32(vlibcountbuf, (vli: u64) * 4u64);
|
|
verneedsz += 16u64 + 16u64 * (cnt: u64);
|
|
vli += 1;
|
|
};
|
|
|
|
let withver: i32 = 0;
|
|
if (nvlibs > 0) { withver = 1; };
|
|
let extra: u64 = 0u64;
|
|
if (withver != 0) { extra = 3u64; };
|
|
let ndyn: u64 = (nsos: u64) + 11u64 + extra;
|
|
let dynamicsz: u64 = ndyn * 16u64;
|
|
|
|
// ---- compute file offsets ----
|
|
let off: u64 = ehdrsz + phdrsz;
|
|
let interpoff: u64 = off; off += interpsz;
|
|
off = alignup(off, 8u64);
|
|
let dynstroff: u64 = off; off += dynstrsz;
|
|
off = alignup(off, 8u64);
|
|
let dynsymoff: u64 = off; off += dynsymsz;
|
|
let hashoff: u64 = off; off += hashsz;
|
|
off = alignup(off, 2u64);
|
|
let versymoff: u64 = off; off += versymsz;
|
|
off = alignup(off, 4u64);
|
|
let verneedoff: u64 = off; off += verneedsz;
|
|
off = alignup(off, 8u64);
|
|
let relapltoff: u64 = off; off += relapltsz;
|
|
|
|
let textoff: u64 = alignup(off, PAGE);
|
|
let pltoff: u64 = textoff + l.textlen;
|
|
let rxend: u64 = pltoff + pltsz;
|
|
|
|
let gotpltoff: u64 = alignup(rxend, PAGE);
|
|
let dynamicoff: u64 = gotpltoff + gotpltsz;
|
|
let dataoff: u64 = dynamicoff + dynamicsz;
|
|
let fileend: u64 = dataoff + l.datalen;
|
|
|
|
let interpva: u64 = base + interpoff;
|
|
let dynstrva: u64 = base + dynstroff;
|
|
let dynsymva: u64 = base + dynsymoff;
|
|
let hashva: u64 = base + hashoff;
|
|
let versymva: u64 = base + versymoff;
|
|
let verneedva: u64 = base + verneedoff;
|
|
let relapltva: u64 = base + relapltoff;
|
|
let textva: u64 = base + textoff;
|
|
let pltva: u64 = base + pltoff;
|
|
let gotpltva: u64 = base + gotpltoff;
|
|
let dynamicva: u64 = base + dynamicoff;
|
|
let datava: u64 = base + dataoff;
|
|
|
|
// Apply relocations now that the dyn layout's textva/datava are
|
|
// pinned. main.ww defers this so each path uses its own VAs.
|
|
if (relocate(l, textva, datava) != 0) { return 1; };
|
|
|
|
// BSS optimisation — same trailing-zero scan as out.ww.
|
|
let bsslen: u64 = 0u64;
|
|
if (l.datalen > 0u64) {
|
|
for (bsslen < l.datalen) {
|
|
let b: u8 = l.data[l.datalen - 1u64 - bsslen];
|
|
if (b != 0u8) { break; };
|
|
bsslen += 1u64;
|
|
};
|
|
};
|
|
let datafilelen: u64 = l.datalen - bsslen;
|
|
let filedataend: u64 = dataoff + datafilelen;
|
|
|
|
// ---- build .dynsym ----
|
|
let dynsymbuf: *u8 = amalloc(a, dynsymsz): *u8;
|
|
pi = 0;
|
|
for (pi < n) {
|
|
let eoff: u64 = (1u64 + (pi: u64)) * 24u64;
|
|
dwr32(dynsymbuf, eoff + 0u64, drdu32(symnamestr, (pi: u64) * 4u64));
|
|
dwr8(dynsymbuf, eoff + 4u64, (STB_GLOBAL_D << 4u8) | (STT_FUNC_D & 15u8));
|
|
dwr8(dynsymbuf, eoff + 5u64, 0u8);
|
|
dwr16(dynsymbuf, eoff + 6u64, 0u16);
|
|
dwr64(dynsymbuf, eoff + 8u64, 0u64);
|
|
dwr64(dynsymbuf, eoff + 16u64, 0u64);
|
|
pi += 1;
|
|
};
|
|
|
|
// ---- build .hash (SysV, 1 bucket) ----
|
|
let hashbuf: *u8 = amalloc(a, hashsz): *u8;
|
|
dwr32(hashbuf, 0u64, nbuckets);
|
|
dwr32(hashbuf, 4u64, nchain);
|
|
let bucket0: u32 = 0u32;
|
|
if (nsymstotal > 1u64) { bucket0 = 1u32; };
|
|
dwr32(hashbuf, 8u64, bucket0);
|
|
let ci: u64 = 1u64;
|
|
for (ci < nsymstotal) {
|
|
let nxt: u32 = 0u32;
|
|
if (ci + 1u64 < nsymstotal) { nxt = (ci + 1u64): u32; };
|
|
dwr32(hashbuf, 8u64 + (nbuckets: u64) * 4u64 + ci * 4u64, nxt);
|
|
ci += 1u64;
|
|
};
|
|
|
|
// ---- build .rela.plt ----
|
|
let relapltbuf: *u8 = amalloc(a, relapltsz): *u8;
|
|
pi = 0;
|
|
for (pi < n) {
|
|
let roff: u64 = (pi: u64) * 24u64;
|
|
dwr64(relapltbuf, roff + 0u64, gotpltva + (3u64 + (pi: u64)) * 8u64);
|
|
let info: u64 = ((1u64 + (pi: u64)) << 32u64) | (R_X86_64_JUMP_SLOT_D: u64);
|
|
dwr64(relapltbuf, roff + 8u64, info);
|
|
dwri64(relapltbuf, roff + 16u64, 0i64);
|
|
pi += 1;
|
|
};
|
|
|
|
// ---- build .gnu.version (u16 per dynsym entry) ----
|
|
let versymbuf: *u8 = amalloc(a, versymsz): *u8;
|
|
dwr16(versymbuf, 0u64, VER_NDX_LOCAL_D);
|
|
pi = 0;
|
|
for (pi < n) {
|
|
dwr16(versymbuf, 2u64 + (pi: u64) * 2u64, drdu16(versymfor, (pi: u64) * 2u64));
|
|
pi += 1;
|
|
};
|
|
|
|
// ---- build .gnu.version_r ----
|
|
let verneedbuf: *u8 = amalloc(a, verneedsz): *u8;
|
|
if (verneedsz > 0u64) {
|
|
let vnoff: u64 = 0u64;
|
|
vli = 0;
|
|
for (vli < nvlibs) {
|
|
let sosidx: i32 = drdi32(vlibsosidxbuf, (vli: u64) * 4u64);
|
|
let first: i32 = drdi32(vlibfirstbuf, (vli: u64) * 4u64);
|
|
let cnt: i32 = drdi32(vlibcountbuf, (vli: u64) * 4u64);
|
|
let vnstart: u64 = vnoff;
|
|
dwr16(verneedbuf, vnoff + 0u64, 1u16);
|
|
dwr16(verneedbuf, vnoff + 2u64, cnt: u16);
|
|
dwr32(verneedbuf, vnoff + 4u64, drdu32(sonamestr, (sosidx: u64) * 4u64));
|
|
dwr32(verneedbuf, vnoff + 8u64, 16u32);
|
|
vnoff += 16u64;
|
|
let k: i32 = 0;
|
|
for (k < cnt) {
|
|
let vk: i32 = first + k;
|
|
let nm: str;
|
|
nm.ptr = vernameptrarr[vk];
|
|
nm.len = drdi32(vernamelenbuf, (vk: u64) * 4u64);
|
|
let h: u32 = elfhash(nm);
|
|
dwr32(verneedbuf, vnoff + 0u64, h);
|
|
dwr16(verneedbuf, vnoff + 4u64, 0u16);
|
|
dwr16(verneedbuf, vnoff + 6u64, drdu16(vervnaother, (vk: u64) * 2u64));
|
|
dwr32(verneedbuf, vnoff + 8u64, drdu32(verdynstroff, (vk: u64) * 4u64));
|
|
let nxt: u32 = 0u32;
|
|
if (k + 1 < cnt) { nxt = 16u32; };
|
|
dwr32(verneedbuf, vnoff + 12u64, nxt);
|
|
vnoff += 16u64;
|
|
k += 1;
|
|
};
|
|
let vnnxt: u32 = 0u32;
|
|
if (vli + 1 < nvlibs) { vnnxt = (vnoff - vnstart): u32; };
|
|
dwr32(verneedbuf, vnstart + 12u64, vnnxt);
|
|
vli += 1;
|
|
};
|
|
};
|
|
|
|
// ---- build .plt ----
|
|
let pltbuf: *u8 = amalloc(a, pltsz): *u8;
|
|
pi = 0;
|
|
for (pi < n) {
|
|
let poff: u64 = (pi: u64) * PLT_STUB_BYTES_D;
|
|
let stubva: u64 = pltva + poff;
|
|
let nextip: u64 = stubva + 6u64;
|
|
let slotva: u64 = gotpltva + (3u64 + (pi: u64)) * 8u64;
|
|
let disp: i64 = (slotva: i64) - (nextip: i64);
|
|
dwr8(pltbuf, poff + 0u64, 255u8);
|
|
dwr8(pltbuf, poff + 1u64, 37u8);
|
|
dwr32(pltbuf, poff + 2u64, (disp: i32): u32);
|
|
pi += 1;
|
|
};
|
|
|
|
// ---- build .got.plt ----
|
|
let gotpltbuf: *u8 = amalloc(a, gotpltsz): *u8;
|
|
dwr64(gotpltbuf, 0u64, dynamicva);
|
|
|
|
// ---- build .dynamic ----
|
|
let dynamicbuf: *u8 = amalloc(a, dynamicsz): *u8;
|
|
let dk: u64 = 0u64;
|
|
pi = 0;
|
|
for (pi < nsos) {
|
|
dwri64(dynamicbuf, dk * 16u64 + 0u64, DT_NEEDED);
|
|
dwr64(dynamicbuf, dk * 16u64 + 8u64, drdu32(sonamestr, (pi: u64) * 4u64): u64);
|
|
dk += 1u64;
|
|
pi += 1;
|
|
};
|
|
dwri64(dynamicbuf, dk * 16u64, DT_HASH); dwr64(dynamicbuf, dk * 16u64 + 8u64, hashva); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_STRTAB); dwr64(dynamicbuf, dk * 16u64 + 8u64, dynstrva); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_SYMTAB); dwr64(dynamicbuf, dk * 16u64 + 8u64, dynsymva); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_STRSZ); dwr64(dynamicbuf, dk * 16u64 + 8u64, dynstrsz); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_SYMENT); dwr64(dynamicbuf, dk * 16u64 + 8u64, 24u64); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_PLTGOT); dwr64(dynamicbuf, dk * 16u64 + 8u64, gotpltva); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_PLTRELSZ); dwr64(dynamicbuf, dk * 16u64 + 8u64, relapltsz); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_PLTREL); dwr64(dynamicbuf, dk * 16u64 + 8u64, DT_RELA: u64);dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_JMPREL); dwr64(dynamicbuf, dk * 16u64 + 8u64, relapltva); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_BIND_NOW); dwr64(dynamicbuf, dk * 16u64 + 8u64, 0u64); dk += 1u64;
|
|
if (withver != 0) {
|
|
dwri64(dynamicbuf, dk * 16u64, DT_VERSYM); dwr64(dynamicbuf, dk * 16u64 + 8u64, versymva); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_VERNEED); dwr64(dynamicbuf, dk * 16u64 + 8u64, verneedva); dk += 1u64;
|
|
dwri64(dynamicbuf, dk * 16u64, DT_VERNEEDNUM); dwr64(dynamicbuf, dk * 16u64 + 8u64, nvlibs: u64);dk += 1u64;
|
|
};
|
|
dwri64(dynamicbuf, dk * 16u64, DT_NULL); dwr64(dynamicbuf, dk * 16u64 + 8u64, 0u64); dk += 1u64;
|
|
if (dk != ndyn) {
|
|
os.write(2, "w6l: dynamic entry count mismatch\n".ptr, 33u64);
|
|
return 1;
|
|
};
|
|
|
|
// ---- patch .text relocs targeting dynamic syms ----
|
|
let r: *lrel = l.rels;
|
|
for (r != nil) {
|
|
if (r.sym != nil) {
|
|
let rsym: *lsym = r.sym;
|
|
if (rsym.isdyn != 0) {
|
|
if (r.kind != R_X86_64_PC32_D) {
|
|
if (r.kind != R_X86_64_PLT32_D) {
|
|
os.write(2, "w6l: dynamic reloc kind unsupported\n".ptr, 35u64);
|
|
return 1;
|
|
};
|
|
};
|
|
let site: u64 = textva + r.off;
|
|
let stub: u64 = pltva + (rsym.pltidx: u64) * PLT_STUB_BYTES_D;
|
|
let disp: i64 = (stub: i64) - (site: i64) + r.addend;
|
|
dwr32(l.text, r.off, (disp: i32): u32);
|
|
};
|
|
};
|
|
r = r.rnext;
|
|
};
|
|
|
|
// ---- assemble file buffer ----
|
|
let filebuf: *u8 = rt.malloc(fileend): *u8;
|
|
if (filebuf == nil) {
|
|
os.write(2, "w6l: out of memory\n".ptr, 18u64);
|
|
return 1;
|
|
};
|
|
|
|
// Ehdr
|
|
dwr8(filebuf, 0u64, 127u8);
|
|
dwr8(filebuf, 1u64, 69u8);
|
|
dwr8(filebuf, 2u64, 76u8);
|
|
dwr8(filebuf, 3u64, 70u8);
|
|
dwr8(filebuf, 4u64, ELFCLASS64_D);
|
|
dwr8(filebuf, 5u64, ELFDATA2LSB_D);
|
|
dwr8(filebuf, 6u64, EV_CURRENT_D: u8);
|
|
dwr16(filebuf, 16u64, ET_EXEC_D);
|
|
dwr16(filebuf, 18u64, EM_X86_64_D);
|
|
dwr32(filebuf, 20u64, EV_CURRENT_D);
|
|
dwr64(filebuf, 24u64, entry);
|
|
dwr64(filebuf, 32u64, ehdrsz);
|
|
dwr64(filebuf, 40u64, 0u64);
|
|
dwr32(filebuf, 48u64, 0u32);
|
|
dwr16(filebuf, 52u64, ehdrsz: u16);
|
|
dwr16(filebuf, 54u64, 56u16);
|
|
dwr16(filebuf, 56u64, nphdrs: u16);
|
|
dwr16(filebuf, 58u64, 0u16);
|
|
dwr16(filebuf, 60u64, 0u16);
|
|
dwr16(filebuf, 62u64, 0u16);
|
|
|
|
// Phdrs at offset 64.
|
|
let p0: u64 = 64u64;
|
|
dwr32(filebuf, p0 + 0u64, PT_LOAD_D);
|
|
dwr32(filebuf, p0 + 4u64, PF_R_D | PF_X_D);
|
|
dwr64(filebuf, p0 + 8u64, 0u64);
|
|
dwr64(filebuf, p0 + 16u64, base);
|
|
dwr64(filebuf, p0 + 24u64, base);
|
|
dwr64(filebuf, p0 + 32u64, rxend);
|
|
dwr64(filebuf, p0 + 40u64, rxend);
|
|
dwr64(filebuf, p0 + 48u64, PAGE);
|
|
|
|
let p1: u64 = 64u64 + 56u64;
|
|
dwr32(filebuf, p1 + 0u64, PT_LOAD_D);
|
|
dwr32(filebuf, p1 + 4u64, PF_R_D | PF_W_D);
|
|
dwr64(filebuf, p1 + 8u64, gotpltoff);
|
|
dwr64(filebuf, p1 + 16u64, gotpltva);
|
|
dwr64(filebuf, p1 + 24u64, gotpltva);
|
|
// filesz trims the .data trailing zeros (BSS); memsz covers
|
|
// .got.plt + .dynamic + the full .data so the loader zero-fills.
|
|
dwr64(filebuf, p1 + 32u64, filedataend - gotpltoff);
|
|
dwr64(filebuf, p1 + 40u64, fileend - gotpltoff);
|
|
dwr64(filebuf, p1 + 48u64, PAGE);
|
|
|
|
let p2: u64 = 64u64 + 112u64;
|
|
dwr32(filebuf, p2 + 0u64, PT_INTERP_D);
|
|
dwr32(filebuf, p2 + 4u64, PF_R_D);
|
|
dwr64(filebuf, p2 + 8u64, interpoff);
|
|
dwr64(filebuf, p2 + 16u64, interpva);
|
|
dwr64(filebuf, p2 + 24u64, interpva);
|
|
dwr64(filebuf, p2 + 32u64, interpsz);
|
|
dwr64(filebuf, p2 + 40u64, interpsz);
|
|
dwr64(filebuf, p2 + 48u64, 1u64);
|
|
|
|
let p3: u64 = 64u64 + 168u64;
|
|
dwr32(filebuf, p3 + 0u64, PT_DYNAMIC_D);
|
|
dwr32(filebuf, p3 + 4u64, PF_R_D | PF_W_D);
|
|
dwr64(filebuf, p3 + 8u64, dynamicoff);
|
|
dwr64(filebuf, p3 + 16u64, dynamicva);
|
|
dwr64(filebuf, p3 + 24u64, dynamicva);
|
|
dwr64(filebuf, p3 + 32u64, dynamicsz);
|
|
dwr64(filebuf, p3 + 40u64, dynamicsz);
|
|
dwr64(filebuf, p3 + 48u64, 8u64);
|
|
|
|
// Sections.
|
|
dbcopy(filebuf, interpoff, INTERP.ptr, INTERP.len: u64);
|
|
dwr8(filebuf, interpoff + (INTERP.len: u64), 0u8);
|
|
dbcopy(filebuf, dynstroff, dynstr, dynstrsz);
|
|
dbcopy(filebuf, dynsymoff, dynsymbuf, dynsymsz);
|
|
dbcopy(filebuf, hashoff, hashbuf, hashsz);
|
|
dbcopy(filebuf, versymoff, versymbuf, versymsz);
|
|
if (verneedsz > 0u64) {
|
|
dbcopy(filebuf, verneedoff, verneedbuf, verneedsz);
|
|
};
|
|
dbcopy(filebuf, relapltoff, relapltbuf, relapltsz);
|
|
if (l.textlen > 0u64) {
|
|
dbcopy(filebuf, textoff, l.text, l.textlen);
|
|
};
|
|
dbcopy(filebuf, pltoff, pltbuf, pltsz);
|
|
dbcopy(filebuf, gotpltoff, gotpltbuf, gotpltsz);
|
|
dbcopy(filebuf, dynamicoff, dynamicbuf, dynamicsz);
|
|
if (datafilelen > 0u64) {
|
|
dbcopy(filebuf, dataoff, l.data, datafilelen);
|
|
};
|
|
|
|
let wr: (i64 | os.oserror) = os.writeall(fd, filebuf, filedataend);
|
|
match (wr) {
|
|
case let v: i64 => { if (v != filedataend: i64) { return 1; }; };
|
|
case let e: os.oserror => return 1;
|
|
};
|
|
return 0;
|
|
};
|
|
|
|
// selfhost/cmd/w6l/out.ww — port of cmd/w6l/out.c.
|
|
//
|
|
// Emit a static ELF64 executable. File layout (per the C original):
|
|
// [0..64) Ehdr
|
|
// [64..120) Phdr (one PT_LOAD)
|
|
// [120..0x1000) zero pad
|
|
// [0x1000..) .text bytes
|
|
// Single PT_LOAD covers the whole file, R+X. No interpreter, no .bss.
|
|
|
|
package w6l;
|
|
|
|
import os;
|
|
import rt;
|
|
import sym;
|
|
import dynout;
|
|
|
|
def ET_EXEC: u16 = 2u16;
|
|
def EM_X86_64_W: u16 = 62u16;
|
|
def EV_CURRENT: u32 = 1u32;
|
|
def ELFCLASS64: u8 = 2u8;
|
|
def ELFDATA2LSB: u8 = 1u8;
|
|
def PT_LOAD: u32 = 1u32;
|
|
def PF_X: u32 = 1u32;
|
|
def PF_W: u32 = 2u32;
|
|
def PF_R: u32 = 4u32;
|
|
|
|
def TEXT_OFF: u64 = 4096u64; // 0x1000
|
|
def PAGE_SZ: u64 = 4096u64;
|
|
|
|
// ---- little-endian byte writers ----------------------------------------
|
|
|
|
fn wru16(buf: *u8, off: u64, v: u16) void = {
|
|
buf[off] = (v & 255u16): u8;
|
|
buf[off + 1u64] = ((v >> 8u16) & 255u16): u8;
|
|
};
|
|
|
|
fn wru32(buf: *u8, off: u64, v: u32) void = {
|
|
buf[off] = (v & 255u32): u8;
|
|
buf[off + 1u64] = ((v >> 8u32) & 255u32): u8;
|
|
buf[off + 2u64] = ((v >> 16u32) & 255u32): u8;
|
|
buf[off + 3u64] = ((v >> 24u32) & 255u32): u8;
|
|
};
|
|
|
|
fn wru64(buf: *u8, off: u64, v: u64) void = {
|
|
wru32(buf, off, (v & 4294967295u64): u32);
|
|
wru32(buf, off + 4u64, ((v >> 32u64) & 4294967295u64): u32);
|
|
};
|
|
|
|
// ---- emit ---------------------------------------------------------------
|
|
|
|
export fn emitelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = {
|
|
// Dispatch: any loaded shared object plus any dynamic ref means
|
|
// we owe the loader a real PT_INTERP/PT_DYNAMIC binary.
|
|
if (l.sos != nil) {
|
|
if (l.dynn > 0) {
|
|
return emitdynelf(l, fd, base, entry);
|
|
};
|
|
};
|
|
|
|
let hasdata: bool = l.datalen > 0u64;
|
|
let rxend: u64 = TEXT_OFF + l.textlen;
|
|
// .data lands at the next page boundary so the loader can give
|
|
// it fresh R+W permissions without overlapping the R+X mapping.
|
|
let dataoff: u64 = 0u64;
|
|
let datava: u64 = 0u64;
|
|
if (hasdata) {
|
|
dataoff = (rxend + PAGE_SZ - 1u64) & ~(PAGE_SZ - 1u64);
|
|
datava = base + dataoff;
|
|
};
|
|
|
|
// Apply relocations now that the layout's textva/datava are
|
|
// known. Deferred from main.ww so the dyn path uses its own
|
|
// datava.
|
|
if (relocate(l, base + TEXT_OFF, datava) != 0) { return -1; };
|
|
|
|
// BSS optimisation: trailing zero bytes in .data can be left
|
|
// out of the file. The loader zero-fills the gap between
|
|
// p_filesz and p_memsz. Scan after l_relocate has applied any
|
|
// DATAR patches — anything still zero at the tail genuinely is
|
|
// zero-init. Matches cmd/w6l/out.c byte-for-byte.
|
|
let bsslen: u64 = 0u64;
|
|
if (hasdata) {
|
|
for (bsslen < l.datalen) {
|
|
let b: u8 = l.data[l.datalen - 1u64 - bsslen];
|
|
if (b != 0u8) { break; };
|
|
bsslen += 1u64;
|
|
};
|
|
};
|
|
let datafilelen: u64 = l.datalen - bsslen;
|
|
|
|
// One contiguous header buffer covering [0..0x1000), then .text.
|
|
let hdr: *u8 = rt.malloc(TEXT_OFF): *u8; // zero-initialised by mmap
|
|
|
|
// --- Ehdr (64 bytes) ---
|
|
hdr[0u64] = 127u8; // 0x7f
|
|
hdr[1u64] = 69u8; // 'E'
|
|
hdr[2u64] = 76u8; // 'L'
|
|
hdr[3u64] = 70u8; // 'F'
|
|
hdr[4u64] = ELFCLASS64;
|
|
hdr[5u64] = ELFDATA2LSB;
|
|
hdr[6u64] = EV_CURRENT: u8;
|
|
wru16(hdr, 16u64, ET_EXEC); // e_type
|
|
wru16(hdr, 18u64, EM_X86_64_W); // e_machine
|
|
wru32(hdr, 20u64, EV_CURRENT); // e_version
|
|
wru64(hdr, 24u64, entry); // e_entry
|
|
wru64(hdr, 32u64, 64u64); // e_phoff = sizeof(Ehdr)
|
|
wru64(hdr, 40u64, 0u64); // e_shoff
|
|
wru32(hdr, 48u64, 0u32); // e_flags
|
|
wru16(hdr, 52u64, 64u16); // e_ehsize
|
|
wru16(hdr, 54u64, 56u16); // e_phentsize
|
|
if (hasdata) { wru16(hdr, 56u64, 2u16); }
|
|
else { wru16(hdr, 56u64, 1u16); };
|
|
wru16(hdr, 58u64, 0u16); // e_shentsize
|
|
wru16(hdr, 60u64, 0u16); // e_shnum
|
|
wru16(hdr, 62u64, 0u16); // e_shstrndx
|
|
|
|
// --- Phdr #1 (R+X) at offset 64 ---
|
|
wru32(hdr, 64u64, PT_LOAD);
|
|
wru32(hdr, 68u64, PF_R | PF_X);
|
|
wru64(hdr, 72u64, 0u64); // p_offset
|
|
wru64(hdr, 80u64, base); // p_vaddr
|
|
wru64(hdr, 88u64, base); // p_paddr
|
|
wru64(hdr, 96u64, rxend); // p_filesz
|
|
wru64(hdr, 104u64, rxend); // p_memsz
|
|
wru64(hdr, 112u64, TEXT_OFF); // p_align
|
|
|
|
if (hasdata) {
|
|
// --- Phdr #2 (R+W) at offset 64+56=120 ---
|
|
wru32(hdr, 120u64, PT_LOAD);
|
|
wru32(hdr, 124u64, PF_R | PF_W);
|
|
wru64(hdr, 128u64, dataoff); // p_offset
|
|
wru64(hdr, 136u64, base + dataoff); // p_vaddr
|
|
wru64(hdr, 144u64, base + dataoff); // p_paddr
|
|
wru64(hdr, 152u64, datafilelen); // p_filesz
|
|
wru64(hdr, 160u64, l.datalen); // p_memsz
|
|
wru64(hdr, 168u64, PAGE_SZ); // p_align
|
|
};
|
|
|
|
// Write [0..0x1000) then .text.
|
|
let r1: (i64 | os.oserror) = os.writeall(fd, hdr, TEXT_OFF);
|
|
let n1: i64 = 0i64;
|
|
match (r1) {
|
|
case let v: i64 => n1 = v;
|
|
case let e: os.oserror => return -1;
|
|
};
|
|
if (n1 != TEXT_OFF: i64) { return -1; };
|
|
if (l.textlen > 0u64) {
|
|
let r2: (i64 | os.oserror) = os.writeall(fd, l.text, l.textlen);
|
|
let n2: i64 = 0i64;
|
|
match (r2) {
|
|
case let v: i64 => n2 = v;
|
|
case let e: os.oserror => return -1;
|
|
};
|
|
if (n2 != l.textlen: i64) { return -1; };
|
|
};
|
|
if (hasdata && datafilelen > 0u64) {
|
|
// Pad to the page-aligned data offset, then write only
|
|
// the non-zero prefix of .data. The rest is BSS — the
|
|
// loader zero-fills from p_filesz to p_memsz.
|
|
let here: u64 = TEXT_OFF + l.textlen;
|
|
let zero: u8 = 0u8;
|
|
for (here < dataoff) {
|
|
let r3: (i64 | os.oserror) = os.writeall(fd, &zero, 1u64);
|
|
match (r3) {
|
|
case let v: i64 => { };
|
|
case let e: os.oserror => return -1;
|
|
};
|
|
here += 1u64;
|
|
};
|
|
let r4: (i64 | os.oserror) = os.writeall(fd, l.data, datafilelen);
|
|
let n4: i64 = 0i64;
|
|
match (r4) {
|
|
case let v: i64 => n4 = v;
|
|
case let e: os.oserror => return -1;
|
|
};
|
|
if (n4 != datafilelen: i64) { return -1; };
|
|
};
|
|
return 0;
|
|
};
|
|
|
|
// selfhost/cmd/w6l/main.ww — port of cmd/w6l/main.c.
|
|
//
|
|
// w6l = amd64 linker. Reads relocatable ELF .o files, SysV `ar`
|
|
// archives, and shared objects (ET_DYN). Resolves symbols, applies
|
|
// relocations, writes a static or dynamic-linked ELF executable.
|
|
//
|
|
// w6l_ww -o out [-L<dir>...] [-l<name>...] file1.o file2.o ...
|
|
|
|
package main;
|
|
|
|
import os;
|
|
import rt;
|
|
import mem;
|
|
import sym;
|
|
import obj;
|
|
import dyn;
|
|
import pass;
|
|
import out;
|
|
|
|
def BASE: u64 = 4194304u64; // 0x400000
|
|
def CODE_VA_OFF: u64 = 4096u64; // .text starts at base + 0x1000
|
|
|
|
fn mklnk(a: *arena) *lnk = {
|
|
let l: *lnk = alloc(lnk { a = a })!;
|
|
return l;
|
|
};
|
|
|
|
// `cstreq` lives in obj.ww — same bundle, single definition.
|
|
|
|
// `cstrlen` lives in obj.ww — same bundle, single definition.
|
|
|
|
// Build "<dir>/lib<name>.<ext>" into dst (NUL-terminated). Returns total
|
|
// length excluding NUL. dst must be large enough.
|
|
fn buildpath(dst: *u8, dir: *u8, name: *u8, ext: str) u64 = {
|
|
let i: u64 = 0u64;
|
|
let dn: u64 = cstrlen(dir);
|
|
let nn: u64 = cstrlen(name);
|
|
let k: u64 = 0u64;
|
|
for (k < dn) { dst[i] = dir[k]; i += 1u64; k += 1u64; };
|
|
dst[i] = 47u8; // '/'
|
|
i += 1u64;
|
|
dst[i] = 108u8; // 'l'
|
|
i += 1u64;
|
|
dst[i] = 105u8; // 'i'
|
|
i += 1u64;
|
|
dst[i] = 98u8; // 'b'
|
|
i += 1u64;
|
|
k = 0u64;
|
|
for (k < nn) { dst[i] = name[k]; i += 1u64; k += 1u64; };
|
|
k = 0u64;
|
|
for (k < ext.len: u64) {
|
|
let li: i32 = k: i32;
|
|
dst[i] = ext[li];
|
|
i += 1u64;
|
|
k += 1u64;
|
|
};
|
|
dst[i] = 0u8;
|
|
return i;
|
|
};
|
|
|
|
// Append decimal n to dst at offset i. Returns new offset.
|
|
fn appenddec(dst: *u8, i: u64, n: u64) u64 = {
|
|
if (n == 0u64) {
|
|
dst[i] = 48u8;
|
|
return i + 1u64;
|
|
};
|
|
let buf: *u8 = rt.malloc(16u64): *u8;
|
|
let k: u64 = 0u64;
|
|
let v: u64 = n;
|
|
for (v > 0u64) {
|
|
buf[k] = (v % 10u64): u8 + 48u8;
|
|
v = v / 10u64;
|
|
k += 1u64;
|
|
};
|
|
let oi: u64 = i;
|
|
for (k > 0u64) {
|
|
k -= 1u64;
|
|
dst[oi] = buf[k];
|
|
oi += 1u64;
|
|
};
|
|
return oi;
|
|
};
|
|
|
|
fn buildpathv(dst: *u8, dir: *u8, name: *u8, v: u64) u64 = {
|
|
let i: u64 = 0u64;
|
|
let dn: u64 = cstrlen(dir);
|
|
let nn: u64 = cstrlen(name);
|
|
let k: u64 = 0u64;
|
|
for (k < dn) { dst[i] = dir[k]; i += 1u64; k += 1u64; };
|
|
dst[i] = 47u8; i += 1u64;
|
|
dst[i] = 108u8; i += 1u64;
|
|
dst[i] = 105u8; i += 1u64;
|
|
dst[i] = 98u8; i += 1u64;
|
|
k = 0u64;
|
|
for (k < nn) { dst[i] = name[k]; i += 1u64; k += 1u64; };
|
|
dst[i] = 46u8; i += 1u64; dst[i] = 115u8; i += 1u64; dst[i] = 111u8; i += 1u64; dst[i] = 46u8; i += 1u64;
|
|
i = appenddec(dst, i, v);
|
|
dst[i] = 0u8;
|
|
return i;
|
|
};
|
|
|
|
// islinkable: read first 8 bytes; require !<arch>\n or \x7fELF.
|
|
fn islinkable(path: *u8) bool = {
|
|
let fd: i32 = os.open(pathstr(path), os.flag.RDONLY, 0i32);
|
|
if (fd < 0) { return false; };
|
|
let mp: *u8 = rt.malloc(8u64): *u8;
|
|
let n: i64 = os.read(fd, mp, 8u64);
|
|
os.close(fd);
|
|
if (n < 4i64) { return false; };
|
|
// archive: "!<arch>\n"
|
|
if (n >= 8i64) {
|
|
if (mp[0u64] == 33u8) { if (mp[1u64] == 60u8) {
|
|
if (mp[2u64] == 97u8) { if (mp[3u64] == 114u8) {
|
|
if (mp[4u64] == 99u8) { if (mp[5u64] == 104u8) {
|
|
if (mp[6u64] == 62u8) { if (mp[7u64] == 10u8) {
|
|
return true;
|
|
}; }; }; }; }; }; }; };
|
|
};
|
|
// ELF: "\x7fELF"
|
|
if (mp[0u64] == 127u8) {
|
|
if (mp[1u64] == 69u8) {
|
|
if (mp[2u64] == 76u8) {
|
|
if (mp[3u64] == 70u8) { return true; };
|
|
};
|
|
};
|
|
};
|
|
return false;
|
|
};
|
|
|
|
// Walk libdirs[0..n) trying lib<name>.so, then lib<name>.so.{0..8},
|
|
// then lib<name>.a. Return arena-owned NUL-terminated path on success,
|
|
// nil on miss.
|
|
fn resolvelib(a: *arena, name: *u8, libdirs: **u8, nlibdirs: i32) *u8 = {
|
|
let bufp: *u8 = rt.malloc(1024u64): *u8;
|
|
let i: i32 = 0;
|
|
for (i < nlibdirs) {
|
|
let dir: *u8 = libdirs[i];
|
|
let _l1: u64 = buildpath(bufp, dir, name, ".so");
|
|
if (islinkable(bufp)) {
|
|
let pl: u64 = cstrlen(bufp);
|
|
let p: *u8 = amalloc(a, pl + 1u64): *u8;
|
|
let k: u64 = 0u64;
|
|
for (k <= pl) { p[k] = bufp[k]; k += 1u64; };
|
|
return p;
|
|
};
|
|
let v: u64 = 0u64;
|
|
for (v <= 8u64) {
|
|
let _l2: u64 = buildpathv(bufp, dir, name, v);
|
|
if (islinkable(bufp)) {
|
|
let pl2: u64 = cstrlen(bufp);
|
|
let p2: *u8 = amalloc(a, pl2 + 1u64): *u8;
|
|
let k2: u64 = 0u64;
|
|
for (k2 <= pl2) { p2[k2] = bufp[k2]; k2 += 1u64; };
|
|
return p2;
|
|
};
|
|
v += 1u64;
|
|
};
|
|
let _l3: u64 = buildpath(bufp, dir, name, ".a");
|
|
if (islinkable(bufp)) {
|
|
let pl3: u64 = cstrlen(bufp);
|
|
let p3: *u8 = amalloc(a, pl3 + 1u64): *u8;
|
|
let k3: u64 = 0u64;
|
|
for (k3 <= pl3) { p3[k3] = bufp[k3]; k3 += 1u64; };
|
|
return p3;
|
|
};
|
|
i += 1;
|
|
};
|
|
return nil;
|
|
};
|
|
|
|
// Read first 20 bytes; return 1 for ET_DYN .so, 0 for ar/.o.
|
|
fn isso(path: *u8) i32 = {
|
|
let fd: i32 = os.open(pathstr(path), os.flag.RDONLY, 0i32);
|
|
if (fd < 0) { return 0; };
|
|
let mp: *u8 = rt.malloc(20u64): *u8;
|
|
let n: i64 = os.read(fd, mp, 20u64);
|
|
os.close(fd);
|
|
if (n < 20i64) { return 0; };
|
|
if (mp[0u64] != 127u8) { return 0; };
|
|
if (mp[1u64] != 69u8) { return 0; };
|
|
if (mp[2u64] != 76u8) { return 0; };
|
|
if (mp[3u64] != 70u8) { return 0; };
|
|
// e_type at offset 16, u16 little-endian
|
|
let t: u16 = (mp[16u64]: u16) | ((mp[17u64]: u16) << 8u16);
|
|
if (t == 3u16) { return 1; };
|
|
return 0;
|
|
};
|
|
|
|
export fn main(argc: i32, argv: **u8) i32 = {
|
|
let outpath: *u8 = nil;
|
|
let maxinputs: i32 = 64;
|
|
let inputs: **u8 = rt.malloc((maxinputs: u64) * 8u64): **u8;
|
|
let ninputs: i32 = 0;
|
|
let libdirs: **u8 = rt.malloc((maxinputs: u64) * 8u64): **u8;
|
|
let nlibdirs: i32 = 0;
|
|
let lflags: **u8 = rt.malloc((maxinputs: u64) * 8u64): **u8;
|
|
let nlflags: i32 = 0;
|
|
|
|
let i: i32 = 1;
|
|
for (i < argc) {
|
|
let a: *u8 = argv[i];
|
|
if (cstreq(a, "-o")) {
|
|
i += 1;
|
|
if (i >= argc) {
|
|
os.write(2, "w6l: -o requires argument\n".ptr, 25u64);
|
|
return 2;
|
|
};
|
|
outpath = argv[i];
|
|
} else { if (cstreq(a, "-L")) {
|
|
i += 1;
|
|
if (i >= argc) {
|
|
os.write(2, "w6l: -L requires argument\n".ptr, 25u64);
|
|
return 2;
|
|
};
|
|
libdirs[nlibdirs] = argv[i];
|
|
nlibdirs += 1;
|
|
} else { if (cstreq(a, "-l")) {
|
|
i += 1;
|
|
if (i >= argc) {
|
|
os.write(2, "w6l: -l requires argument\n".ptr, 25u64);
|
|
return 2;
|
|
};
|
|
lflags[nlflags] = argv[i];
|
|
nlflags += 1;
|
|
} else { if (a[0u64] == 45u8) {
|
|
// -L<dir> joined form.
|
|
if (a[1u64] == 76u8) {
|
|
if (a[2u64] != 0u8) {
|
|
libdirs[nlibdirs] = a + 2u64;
|
|
nlibdirs += 1;
|
|
} else {
|
|
os.write(2, "w6l: bare -L\n".ptr, 12u64);
|
|
return 2;
|
|
};
|
|
} else { if (a[1u64] == 108u8) {
|
|
if (a[2u64] != 0u8) {
|
|
lflags[nlflags] = a + 2u64;
|
|
nlflags += 1;
|
|
} else {
|
|
os.write(2, "w6l: bare -l\n".ptr, 12u64);
|
|
return 2;
|
|
};
|
|
} else {
|
|
os.write(2, "w6l: unknown flag\n".ptr, 17u64);
|
|
return 2;
|
|
};};
|
|
} else {
|
|
if (ninputs >= maxinputs) {
|
|
os.write(2, "w6l: too many inputs\n".ptr, 20u64);
|
|
return 2;
|
|
};
|
|
inputs[ninputs] = a;
|
|
ninputs += 1;
|
|
};};};};
|
|
i += 1;
|
|
};
|
|
|
|
if (outpath == nil) {
|
|
os.write(2, "usage: w6l_ww -o exe [-L<dir>...] [-l<name>...] file1.o [file2.o...]\n".ptr, 68u64);
|
|
return 2;
|
|
};
|
|
if (ninputs == 0) {
|
|
os.write(2, "w6l: no inputs\n".ptr, 14u64);
|
|
return 2;
|
|
};
|
|
|
|
let a: *arena = newarena();
|
|
let l: *lnk = mklnk(a);
|
|
|
|
// Seed _start so libwwrt-style start.o is recognised as wanted.
|
|
intern(l, "_start");
|
|
|
|
// Load positional inputs first (preserving order).
|
|
let k: i32 = 0;
|
|
for (k < ninputs) {
|
|
if (load(l, inputs[k]) != 0) {
|
|
return 1;
|
|
};
|
|
k += 1;
|
|
};
|
|
|
|
// Then resolve -l flags and load each. Archives append; shared
|
|
// objects register their exports.
|
|
let lf: i32 = 0;
|
|
for (lf < nlflags) {
|
|
let p: *u8 = resolvelib(a, lflags[lf], libdirs, nlibdirs);
|
|
if (p == nil) {
|
|
os.write(2, "w6l: cannot find -l".ptr, 18u64);
|
|
let nm: *u8 = lflags[lf];
|
|
os.write(2, nm, cstrlen(nm));
|
|
os.write(2, "\n".ptr, 1u64);
|
|
return 1;
|
|
};
|
|
if (isso(p) != 0) {
|
|
if (loadso(l, p) != 0) { return 1; };
|
|
} else {
|
|
if (load(l, p) != 0) { return 1; };
|
|
};
|
|
lf += 1;
|
|
};
|
|
|
|
if (resolve(l) != 0) { return 1; };
|
|
// Relocation is deferred to the emit functions — each path
|
|
// knows its own layout (textva, datava); the static and dyn
|
|
// paths place .data at different VAs.
|
|
|
|
let entrysym: *lsym = lookup(l, "_start");
|
|
if (entrysym == nil) { entrysym = lookup(l, "main"); }
|
|
else { if (entrysym.defined == 0) { entrysym = lookup(l, "main"); }; };
|
|
if (entrysym == nil) {
|
|
os.write(2, "w6l: no _start or main symbol\n".ptr, 29u64);
|
|
return 1;
|
|
};
|
|
if (entrysym.defined == 0) {
|
|
os.write(2, "w6l: no _start or main symbol\n".ptr, 29u64);
|
|
return 1;
|
|
};
|
|
|
|
let flags: os.flag = os.flag.WRONLY | os.flag.CREATE | os.flag.TRUNC;
|
|
let fd: i32 = os.open(pathstr(outpath), flags, 493i32); // 0o755
|
|
if (fd < 0) {
|
|
os.write(2, "w6l: cannot open output\n".ptr, 23u64);
|
|
return 1;
|
|
};
|
|
|
|
let entryva: u64 = BASE + CODE_VA_OFF + entrysym.val;
|
|
let rc: i32 = emitelf(l, fd, BASE, entryva);
|
|
os.close(fd);
|
|
return rc;
|
|
};
|
|
|