ww/selfhost/cmd/w6l/obj.ww

// Port of cmd/w6l/obj.c.

package main;

import os;
import rt;
import strings;

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;

// ELF64/x86-64 is little-endian; bytewise decoding also avoids alignment
// and host-layout assumptions about input buffers.

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);
};

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;

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 = alloc([], n: u64)!;
	buf.len = n: i32;
	let rr: (i64 | os.oserror) = os.readall(fd, buf.ptr, 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.ptr, n: u64;
};

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 = alloc([], nc)!;
		let i: u64 = 0u64;
		for (i < l.textlen) {
			nb[i] = l.text[i];
			i += 1u64;
		};
		l.text = nb.ptr;
		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 = alloc([], nc)!;
		let i: u64 = 0u64;
		for (i < l.datalen) {
			nb[i] = l.data[i];
			i += 1u64;
		};
		l.data = nb.ptr;
		l.datacap = nc;
	};
	let i: u64 = 0u64;
	for (i < n) {
		l.data[l.datalen + i] = src[i];
		i += 1u64;
	};
	l.datalen += n;
};

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

// Bridges argv-style callers to lib/os entrypoints (str post-task-#23).
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;
};

fn cstrtostr(p: *u8) str = {
	let n: u64 = cstrlen(p);
	let view: str;
	view.ptr = p;
	view.len = n: i32;
	return strings.dup(view);
};

// 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,		// owned heap 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] != '!' || p[1u64] != '<' || p[2u64] != 'a' || p[3u64] != 'r' ||
			p[4u64] != 'c' || p[5u64] != 'h' || p[6u64] != '>' ||
			p[7u64] != '\n') {
		return false;
	};
	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;
};

// Names are owned heap copies, so the source ELF buffer can be freed
// afterward.
fn elfglobals(buf: *u8, len: u64) *defent = {
	if (len < EHDR_SIZE) { return nil; };
	if (buf[0u64] != 127u8) { return nil; };
	if (buf[1u64] != 'E')  { return nil; };
	if (buf[2u64] != 'L')  { return nil; };
	if (buf[3u64] != 'F')  { 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(nmp);
						let de: *defent = alloc(defent { name = nm, dnext = head })!;
						head = de;
					};
				};
			};
		};
		si += 1u64;
	};
	return head;
};

// 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];
		// '/'-led names: '/ ' is the symbol index and '//' the GNU
		// long-name table — neither is an object. '/N' (digits) IS
		// a real member whose name lives in that table; names are
		// never consulted here, so index it by content. Pre-fix
		// every long-named (>15 char) member was silently skipped
		// and its definitions never linked.
		let second: u8 = buf[pos + 1u64];
		let special: bool = (first == '/'
		    && (second == ' ' || second == '/'))
		    || first == 0u8 || first == ' ';
		if (!special) {
			let m: *armember = alloc(armember { size = hdrsize })!;
			let mbs: []u8 = alloc([], hdrsize)!;
			let mb: *u8 = mbs.ptr;
			let i: u64 = 0u64;
			for (i < hdrsize) {
				mb[i] = buf[hdrend + i];
				i += 1u64;
			};
			m.data = mb;
			m.defs = elfglobals(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;
					} else {
						// a member that fails to parse must
						// fail the link, not stay silently
						// unlinked (rule 7). Consumed either
						// way.
						let mbad: str = "w6l: bad archive member\n";
						os.write(2, mbad.ptr, mbad.len: u64);
						l.errs += 1;
						m.loaded = 1;
					};
				};
			};
			m = m.mnext;
		};
	};

	// Pass 3 (#31, task #62): catch a dup the selective pull MASKED. A
	// member pass 2 left unloaded yet defining a name some other object
	// already `defined` is exactly the cross-package collision archive
	// selective-pull would silently skip. lookup (never intern) keeps
	// the pull machinery untouched → byte-id-neutral on every clean
	// link. Pulled-member and direct-`.o` dups stay caught in loadimage.
	// ww has no weak symbols → a genuine dup. (The bare message matches
	// loadimage's; the w6l path+name text divergence is #61, separate.)
	let dm: *armember = head;
	for (dm != nil) {
		if (dm.loaded == 0) {
			let de: *defent = dm.defs;
			for (de != nil) {
				let s: *lsym = lookup(l, de.name);
				if (s != nil) {
					if (s.defined != 0) {
						let msg: str = "w6l: duplicate symbol\n";
						os.write(2, msg.ptr, msg.len: u64);
						l.errs += 1;
					};
				};
				de = de.dnext;
			};
		};
		dm = dm.mnext;
	};
	return 0;
};

export fn load(l: *lnk, path: *u8) i32 = {
	let bufp: *u8;
	let buflen: u64;
	bufp, buflen = slurp(path);
	if (bufp == nil) {
		let m: str = "w6l: cannot read object\n";
		os.write(2, m.ptr, m.len: u64);
		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] != 'E')  { return -1; };
	if (buf[2u64] != 'L')  { return -1; };
	if (buf[3u64] != 'F')  { 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;

	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) {
		let m: str = "w6l: missing .text\n";
		os.write(2, m.ptr, m.len: u64);
		return -1;
	};
	if (idxsymtab < 0) {
		let m: str = "w6l: missing .symtab\n";
		os.write(2, m.ptr, m.len: u64);
		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);
	};

	let ob: *lobj = alloc(lobj {
		path     = cstrtostr(path),
		buf      = buf,
		len      = len,
		textoff  = l.textlen,
		textsize = textsize,
		dataoff  = l.datalen,
		datasize = datasize,
		onext    = l.objs,
	})!;
	l.objs = ob;

	emittext(l, buf + textoff, textsize);
	if (idxdata >= 0) {
		if (datasize > 0u64) {
			emitdata(l, buf + dataoff, datasize);
		};
	};

	// Rewalking avoids retaining an nsyms-sized per-object map solely
	// for relocation lookup.
	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(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 (gs.defined != 0) {
						let m: str = "w6l: duplicate symbol\n";
						os.write(2, m.ptr, m.len: u64);
						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) {
						let m: str = "w6l: duplicate symbol\n";
						os.write(2, m.ptr, m.len: u64);
						l.errs += 1;
					} else {
						gs.defined = 1;
						gs.indata = 1;
						gs.owner = ob;
						gs.idxinowner = si: i32;
						gs.val = ob.dataoff + stvalue;
					};
				};
			};
		};
		si += 1u64;
	};

	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,
			})!;
			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(snm);
					nr.sym = intern(l, nm);
				};
			};
			l.rels = nr;
			ri += 1u64;
		};
	};

	// Offsets land in .data, shifted by this object's dataoff 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(snm);
					nr.sym = intern(l, nm);
				};
			};
			l.rels = nr;
			ri += 1u64;
		};
	};

	return 0;
};