320 lines
8.3 KiB
Plaintext
320 lines
8.3 KiB
Plaintext
// Port of cmd/w6l/main.c.
|
|
//
|
|
// w6l_ww -o out [-L<dir>...] [-l<name>...] file1.o file2.o ...
|
|
|
|
package main;
|
|
|
|
import os;
|
|
import strings;
|
|
|
|
def BASE: u64 = 4194304u64; // 0x400000
|
|
def CODE_VA_OFF: u64 = 4096u64; // .text starts at base + 0x1000
|
|
|
|
fn mklnk() *lnk = {
|
|
let l: *lnk = alloc(lnk { })!;
|
|
return l;
|
|
};
|
|
|
|
// 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] = '/';
|
|
i += 1u64;
|
|
dst[i] = 'l';
|
|
i += 1u64;
|
|
dst[i] = 'i';
|
|
i += 1u64;
|
|
dst[i] = '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: [16]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] = '/'; i += 1u64;
|
|
dst[i] = 'l'; i += 1u64;
|
|
dst[i] = 'i'; i += 1u64;
|
|
dst[i] = 'b'; i += 1u64;
|
|
k = 0u64;
|
|
for (k < nn) { dst[i] = name[k]; i += 1u64; k += 1u64; };
|
|
dst[i] = '.'; i += 1u64; dst[i] = 's'; i += 1u64; dst[i] = 'o'; i += 1u64; dst[i] = '.'; 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: [8]u8;
|
|
let n: i64 = os.read(fd, &mp[0], 8u64);
|
|
os.close(fd);
|
|
if (n < 4i64) { return false; };
|
|
// hasprefix length-bails when the header is shorter than the magic,
|
|
// matching the old n>=8 archive guard (str len < 8 => no match).
|
|
let hn: i32 = n: i32;
|
|
let hdr: str = strings.frombytes(mp[0:hn]);
|
|
if (strings.hasprefix(hdr, "!<arch>\n")) { return true; };
|
|
if (strings.hasprefix(hdr, "\x7fELF")) { return true; };
|
|
return false;
|
|
};
|
|
|
|
// Walk libdirs[0..n) trying lib<name>.so, then lib<name>.so.{0..8},
|
|
// then lib<name>.a. Return a heap-allocated NUL-terminated path on
|
|
// success, nil on miss.
|
|
fn resolvelib(name: *u8, libdirs: **u8, nlibdirs: i32) *u8 = {
|
|
let bufp: []u8 = alloc([], 1024u64)!;
|
|
bufp.len = 1024;
|
|
let i: i32 = 0;
|
|
for (i < nlibdirs) {
|
|
let dir: *u8 = libdirs[i];
|
|
let _l1: u64 = buildpath(bufp.ptr, dir, name, ".so");
|
|
if (islinkable(bufp.ptr)) {
|
|
let pl: u64 = cstrlen(bufp.ptr);
|
|
let p: []u8 = alloc([], pl + 1u64)!;
|
|
let k: u64 = 0u64;
|
|
for (k <= pl) { p[k] = bufp[k]; k += 1u64; };
|
|
return p.ptr;
|
|
};
|
|
let v: u64 = 0u64;
|
|
for (v <= 8u64) {
|
|
let _l2: u64 = buildpathv(bufp.ptr, dir, name, v);
|
|
if (islinkable(bufp.ptr)) {
|
|
let pl2: u64 = cstrlen(bufp.ptr);
|
|
let p2: []u8 = alloc([], pl2 + 1u64)!;
|
|
let k2: u64 = 0u64;
|
|
for (k2 <= pl2) { p2[k2] = bufp[k2]; k2 += 1u64; };
|
|
return p2.ptr;
|
|
};
|
|
v += 1u64;
|
|
};
|
|
let _l3: u64 = buildpath(bufp.ptr, dir, name, ".a");
|
|
if (islinkable(bufp.ptr)) {
|
|
let pl3: u64 = cstrlen(bufp.ptr);
|
|
let p3: []u8 = alloc([], pl3 + 1u64)!;
|
|
let k3: u64 = 0u64;
|
|
for (k3 <= pl3) { p3[k3] = bufp[k3]; k3 += 1u64; };
|
|
return p3.ptr;
|
|
};
|
|
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: [20]u8;
|
|
let n: i64 = os.read(fd, &mp[0], 20u64);
|
|
os.close(fd);
|
|
if (n < 20i64) { return 0; };
|
|
let hdr: str = strings.frombytes(mp[0:4]);
|
|
if (!strings.hasprefix(hdr, "\x7fELF")) { 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;
|
|
// argc is the upper bound on flags/inputs (one each per argv slot),
|
|
// mirroring cstage's calloc(argc, ...). No fixed cap.
|
|
let inputs: []*u8 = alloc([], argc: u64)!;
|
|
inputs.len = argc;
|
|
let ninputs: i32 = 0;
|
|
let libdirs: []*u8 = alloc([], argc: u64)!;
|
|
libdirs.len = argc;
|
|
let nlibdirs: i32 = 0;
|
|
let lflags: []*u8 = alloc([], argc: u64)!;
|
|
lflags.len = argc;
|
|
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) {
|
|
let m: str = "w6l: -o requires argument\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};
|
|
outpath = argv[i];
|
|
} else { if (cstreq(a, "-L")) {
|
|
i += 1;
|
|
if (i >= argc) {
|
|
let m: str = "w6l: -L requires argument\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};
|
|
libdirs[nlibdirs] = argv[i];
|
|
nlibdirs += 1;
|
|
} else { if (cstreq(a, "-l")) {
|
|
i += 1;
|
|
if (i >= argc) {
|
|
let m: str = "w6l: -l requires argument\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};
|
|
lflags[nlflags] = argv[i];
|
|
nlflags += 1;
|
|
} else { if (a[0u64] == '-') {
|
|
// -L<dir> joined form.
|
|
if (a[1u64] == 'L') {
|
|
if (a[2u64] != 0u8) {
|
|
libdirs[nlibdirs] = a + 2u64;
|
|
nlibdirs += 1;
|
|
} else {
|
|
let m: str = "w6l: bare -L\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};
|
|
} else { if (a[1u64] == 'l') {
|
|
if (a[2u64] != 0u8) {
|
|
lflags[nlflags] = a + 2u64;
|
|
nlflags += 1;
|
|
} else {
|
|
let m: str = "w6l: bare -l\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};
|
|
} else {
|
|
let m: str = "w6l: unknown flag\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};};
|
|
} else {
|
|
inputs[ninputs] = a;
|
|
ninputs += 1;
|
|
};};};};
|
|
i += 1;
|
|
};
|
|
|
|
if (outpath == nil) {
|
|
let m: str = "usage: w6l_ww -o exe [-L<dir>...] [-l<name>...] file1.o [file2.o...]\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};
|
|
if (ninputs == 0) {
|
|
let m: str = "w6l: no inputs\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 2;
|
|
};
|
|
|
|
let l: *lnk = mklnk();
|
|
|
|
// Seed both accepted entries before archive loading. This lets the root
|
|
// package arrive as an ordinary selective-pull archive.
|
|
intern(l, "_start");
|
|
intern(l, "main");
|
|
|
|
// Load positional inputs first (preserving order).
|
|
let k: i32 = 0;
|
|
for (k < ninputs) {
|
|
if (load(l, inputs[k]) != 0) {
|
|
return 1;
|
|
};
|
|
k += 1;
|
|
};
|
|
|
|
// Archives append; shared objects register their exports.
|
|
let lf: i32 = 0;
|
|
for (lf < nlflags) {
|
|
let p: *u8 = resolvelib(lflags[lf], libdirs.ptr, nlibdirs);
|
|
if (p == nil) {
|
|
let m: str = "w6l: cannot find -l";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
let nm: *u8 = lflags[lf];
|
|
os.write(2, nm, cstrlen(nm));
|
|
let nl: str = "\n";
|
|
os.write(2, nl.ptr, nl.len: u64);
|
|
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) {
|
|
let m: str = "w6l: no _start or main symbol\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 1;
|
|
};
|
|
if (entrysym.defined == 0) {
|
|
let m: str = "w6l: no _start or main symbol\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 1;
|
|
};
|
|
|
|
// Pinned Go's BuildInstallFunc creates an ordinary linked command with
|
|
// 0o777; open applies the invoking process's umask to this fresh stage.
|
|
let flags: os.flag = os.flag.WRONLY | os.flag.CREATE | os.flag.TRUNC;
|
|
let fd: i32 = os.open(pathstr(outpath), flags, 511i32); // 0o777
|
|
if (fd < 0) {
|
|
let m: str = "w6l: cannot open output\n";
|
|
os.write(2, m.ptr, m.len: u64);
|
|
return 1;
|
|
};
|
|
|
|
let entryva: u64 = BASE + CODE_VA_OFF + entrysym.val;
|
|
let rc: i32 = emitelf(l, fd, BASE, entryva);
|
|
os.close(fd);
|
|
return rc;
|
|
};
|