ww: rename toolchain to w-prefix + hare-style build/run/test driver
Plan 9-style w-prefix on the per-arch tools, disambiguating from the
real Plan 9 6c/6a/6l in ref/plan9front/:
cmd/wwc/ → cmd/wcc/ libwwc.a → libwcc.a
cmd/6{c,a,l} → cmd/w6{c,a,l} binary names too
test/wwc/ → test/wcc/ 6 test files w/ w6 prefix
selfhost/cmd mirror in lockstep
bootstrap/amd64/{w6c,w6a,w6l} snapshot binaries (gitignored)
WW_6{C,A,L} → WW_W6{C,A,L} env-var overrides
Plan 9 source-tree refs ("Plan 9 6c shape", ref/plan9front/, etc.)
preserved. Hare-style driver, both C and ww sides:
ww test [path] discover *_test.ww in a directory module, run
each; single-file mode for `ww test foo.ww`
Module-by-name `ww build foo` resolves to foo.ww or foo/foo.ww
via search path (cwd : -I dirs : $WW_LIB)
Default-to-cwd `ww build` / `ww test` build the cwd module
Run pass-through `ww run path arg1 arg2` reaches the program
lib/os: getcwd (79) and getdents64 (217) syscalls power `.` resolution
and directory enumeration on the ww side.
Makefile: wwstage tool deps now include lib/os/os.ww (+ lib/strconv
for wwdump_ww) so lib/* edits force their rebuild instead of leaving
stale binaries — surfaced when test 995 first failed against a stale
w6c_ww built before the lib/os additions.
Test 993 byte-identical parity gate (C-side ww vs ww-side ww_ww on a
build corpus) stays green; all 19 tests pass.
This commit is contained in:
352
selfhost/cmd/w6l/main.ww
Normal file
352
selfhost/cmd/w6l/main.ww
Normal file
@@ -0,0 +1,352 @@
|
||||
// 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 ...
|
||||
|
||||
use os;
|
||||
use mem;
|
||||
use sym;
|
||||
use obj;
|
||||
use dyn;
|
||||
use pass;
|
||||
use out;
|
||||
|
||||
def BASE: u64 = 4194304u64; // 0x400000
|
||||
def CODE_VA_OFF: u64 = 4096u64; // .text starts at base + 0x1000
|
||||
|
||||
fn make_lnk(a: *arena) *lnk = {
|
||||
let l: *lnk = amalloc(a, 112u64): *lnk;
|
||||
l.a = a;
|
||||
return l;
|
||||
};
|
||||
|
||||
fn streq_cs(a: *u8, lit: str) bool = {
|
||||
let n: u64 = lit.len: u64;
|
||||
let i: u64 = 0u64;
|
||||
for (i < n) {
|
||||
let li: i32 = i: i32;
|
||||
if (a[i] != lit[li]) { return false; };
|
||||
i += 1u64;
|
||||
};
|
||||
if (a[i] != 0u8) { return false; };
|
||||
return true;
|
||||
};
|
||||
|
||||
fn cstrlen_l(p: *u8) u64 = {
|
||||
let n: u64 = 0u64;
|
||||
for (p[n] != 0u8) { n += 1u64; };
|
||||
return n;
|
||||
};
|
||||
|
||||
// strncmp(a, lit, n): true iff a's first n bytes == lit's first n bytes.
|
||||
fn strn_eq(a: *u8, lit: str, n: u64) bool = {
|
||||
if ((lit.len: u64) < n) { return false; };
|
||||
let i: u64 = 0u64;
|
||||
for (i < n) {
|
||||
let li: i32 = i: i32;
|
||||
if (a[i] != lit[li]) { return false; };
|
||||
i += 1u64;
|
||||
};
|
||||
return true;
|
||||
};
|
||||
|
||||
// Build "<dir>/lib<name>.<ext>" into dst (NUL-terminated). Returns total
|
||||
// length excluding NUL. dst must be large enough.
|
||||
fn build_path(dst: *u8, dir: *u8, name: *u8, ext: str) u64 = {
|
||||
let i: u64 = 0u64;
|
||||
let dn: u64 = cstrlen_l(dir);
|
||||
let nn: u64 = cstrlen_l(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 append_dec(dst: *u8, i: u64, n: u64) u64 = {
|
||||
if (n == 0u64) {
|
||||
dst[i] = 48u8;
|
||||
return i + 1u64;
|
||||
};
|
||||
let buf: *u8 = os.alloc(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 build_path_v(dst: *u8, dir: *u8, name: *u8, v: u64) u64 = {
|
||||
let i: u64 = 0u64;
|
||||
let dn: u64 = cstrlen_l(dir);
|
||||
let nn: u64 = cstrlen_l(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 = append_dec(dst, i, v);
|
||||
dst[i] = 0u8;
|
||||
return i;
|
||||
};
|
||||
|
||||
// is_linkable: read first 8 bytes; require !<arch>\n or \x7fELF.
|
||||
fn is_linkable(path: *u8) bool = {
|
||||
let fd: i32 = os.open(path, os.O_RDONLY, 0i32);
|
||||
if (fd < 0) { return false; };
|
||||
let mp: *u8 = os.alloc(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 resolve_lib(a: *arena, name: *u8, libdirs: **u8, n_libdirs: i32) *u8 = {
|
||||
let bufp: *u8 = os.alloc(1024u64): *u8;
|
||||
let i: i32 = 0;
|
||||
for (i < n_libdirs) {
|
||||
let dir: *u8 = libdirs[i];
|
||||
let _l1: u64 = build_path(bufp, dir, name, ".so");
|
||||
if (is_linkable(bufp)) {
|
||||
let pl: u64 = cstrlen_l(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 = build_path_v(bufp, dir, name, v);
|
||||
if (is_linkable(bufp)) {
|
||||
let pl2: u64 = cstrlen_l(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 = build_path(bufp, dir, name, ".a");
|
||||
if (is_linkable(bufp)) {
|
||||
let pl3: u64 = cstrlen_l(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 is_so(path: *u8) i32 = {
|
||||
let fd: i32 = os.open(path, os.O_RDONLY, 0i32);
|
||||
if (fd < 0) { return 0; };
|
||||
let mp: *u8 = os.alloc(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 out_path: *u8 = nil;
|
||||
let max_inputs: i32 = 64;
|
||||
let inputs: **u8 = os.alloc((max_inputs: u64) * 8u64): **u8;
|
||||
let ninputs: i32 = 0;
|
||||
let libdirs: **u8 = os.alloc((max_inputs: u64) * 8u64): **u8;
|
||||
let n_libdirs: i32 = 0;
|
||||
let lflags: **u8 = os.alloc((max_inputs: u64) * 8u64): **u8;
|
||||
let n_lflags: i32 = 0;
|
||||
|
||||
let i: i32 = 1;
|
||||
for (i < argc) {
|
||||
let a: *u8 = argv[i];
|
||||
if (streq_cs(a, "-o")) {
|
||||
i += 1;
|
||||
if (i >= argc) {
|
||||
os.write(2, "w6l: -o requires argument\n".ptr, 25u64);
|
||||
return 2;
|
||||
};
|
||||
out_path = argv[i];
|
||||
} else { if (streq_cs(a, "-L")) {
|
||||
i += 1;
|
||||
if (i >= argc) {
|
||||
os.write(2, "w6l: -L requires argument\n".ptr, 25u64);
|
||||
return 2;
|
||||
};
|
||||
libdirs[n_libdirs] = argv[i];
|
||||
n_libdirs += 1;
|
||||
} else { if (streq_cs(a, "-l")) {
|
||||
i += 1;
|
||||
if (i >= argc) {
|
||||
os.write(2, "w6l: -l requires argument\n".ptr, 25u64);
|
||||
return 2;
|
||||
};
|
||||
lflags[n_lflags] = argv[i];
|
||||
n_lflags += 1;
|
||||
} else { if (a[0u64] == 45u8) {
|
||||
// -L<dir> joined form.
|
||||
if (a[1u64] == 76u8) {
|
||||
if (a[2u64] != 0u8) {
|
||||
libdirs[n_libdirs] = a + 2u64;
|
||||
n_libdirs += 1;
|
||||
} else {
|
||||
os.write(2, "w6l: bare -L\n".ptr, 12u64);
|
||||
return 2;
|
||||
};
|
||||
} else { if (a[1u64] == 108u8) {
|
||||
if (a[2u64] != 0u8) {
|
||||
lflags[n_lflags] = a + 2u64;
|
||||
n_lflags += 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 >= max_inputs) {
|
||||
os.write(2, "w6l: too many inputs\n".ptr, 20u64);
|
||||
return 2;
|
||||
};
|
||||
inputs[ninputs] = a;
|
||||
ninputs += 1;
|
||||
};};};};
|
||||
i += 1;
|
||||
};
|
||||
|
||||
if (out_path == 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 = make_lnk(a);
|
||||
|
||||
// Seed _start so libwwrt-style start.o is recognised as wanted.
|
||||
l_intern(l, "_start");
|
||||
|
||||
// Load positional inputs first (preserving order).
|
||||
let k: i32 = 0;
|
||||
for (k < ninputs) {
|
||||
if (l_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 < n_lflags) {
|
||||
let p: *u8 = resolve_lib(a, lflags[lf], libdirs, n_libdirs);
|
||||
if (p == nil) {
|
||||
os.write(2, "w6l: cannot find -l".ptr, 18u64);
|
||||
let nm: *u8 = lflags[lf];
|
||||
os.write(2, nm, cstrlen_l(nm));
|
||||
os.write(2, "\n".ptr, 1u64);
|
||||
return 1;
|
||||
};
|
||||
if (is_so(p) != 0) {
|
||||
if (l_load_so(l, p) != 0) { return 1; };
|
||||
} else {
|
||||
if (l_load(l, p) != 0) { return 1; };
|
||||
};
|
||||
lf += 1;
|
||||
};
|
||||
|
||||
if (l_resolve(l) != 0) { return 1; };
|
||||
if (l_relocate(l, BASE + CODE_VA_OFF) != 0) { return 1; };
|
||||
|
||||
let entry_sym: *lsym = l_lookup(l, "_start");
|
||||
if (entry_sym == nil) { entry_sym = l_lookup(l, "main"); }
|
||||
else { if (entry_sym.defined == 0) { entry_sym = l_lookup(l, "main"); }; };
|
||||
if (entry_sym == nil) {
|
||||
os.write(2, "w6l: no _start or main symbol\n".ptr, 29u64);
|
||||
return 1;
|
||||
};
|
||||
if (entry_sym.defined == 0) {
|
||||
os.write(2, "w6l: no _start or main symbol\n".ptr, 29u64);
|
||||
return 1;
|
||||
};
|
||||
|
||||
let flags: i32 = os.O_WRONLY | os.O_CREAT | os.O_TRUNC;
|
||||
let fd: i32 = os.open(out_path, flags, 493i32); // 0o755
|
||||
if (fd < 0) {
|
||||
os.write(2, "w6l: cannot open output\n".ptr, 23u64);
|
||||
return 1;
|
||||
};
|
||||
|
||||
let entry_va: u64 = BASE + CODE_VA_OFF + entry_sym.val;
|
||||
let rc: i32 = l_emit_elf(l, fd, BASE, entry_va);
|
||||
os.close(fd);
|
||||
return rc;
|
||||
};
|
||||
Reference in New Issue
Block a user