// 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.

use os;
use mem;
use 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 readall(path: *u8) (*u8, u64) = {
	let fd: i32 = os.open(path, os.O_RDONLY, 0i32);
	if (fd < 0) { return nil, 0u64; };
	let n: i64 = os.filesize(fd);
	if (n < 0i64) { os.close(fd); return nil, 0u64; };
	let buf: *u8 = os.alloc(n: u64): *u8;
	let got: i64 = os.readfull(fd, buf, n: u64);
	os.close(fd);
	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 = os.alloc(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;
};

// ---- C-string helpers --------------------------------------------------

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

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 shstr_sh_off: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
	let shstr: *u8 = buf + shstr_sh_off;

	let idx_text:   i32 = -1;
	let idx_symtab: i32 = -1;
	let i: u32 = 0u32;
	for (i < shnum) {
		let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE;
		let sh_type: u32 = rdu32(buf, sh_off + SHDR_TYPE);
		let sh_name: u32 = rdu32(buf, sh_off + SHDR_NAME);
		let nm: *u8 = shstr + (sh_name: u64);
		if (sh_type == SHT_PROGBITS: u32) {
			if (cstreq(nm, ".text")) { idx_text = i: i32; };
		};
		if (sh_type == SHT_SYMTAB: u32)  { idx_symtab = i: i32; };
		i += 1u32;
	};
	if (idx_text < 0) { return nil; };
	if (idx_symtab < 0) { return nil; };

	let sym_sh:   u64 = shoff + (idx_symtab: u64) * SHDR_SIZE;
	let sym_off:  u64 = rdu64(buf, sym_sh + SHDR_OFFSET);
	let sym_size: u64 = rdu64(buf, sym_sh + SHDR_SIZE_F);
	let sym_link: u32 = rdu32(buf, sym_sh + SHDR_LINK);
	let nsyms:    u64 = sym_size / SYM_SIZE;

	let str_sh:  u64 = shoff + (sym_link: u64) * SHDR_SIZE;
	let str_off: u64 = rdu64(buf, str_sh + SHDR_OFFSET);
	let strtab:  *u8 = buf + str_off;

	let head: *defent = nil;
	let si: u64 = 1u64;
	for (si < nsyms) {
		let sym_p: u64 = sym_off + si * SYM_SIZE;
		let st_name:  u32 = rdu32(buf, sym_p + SYM_NAME);
		let st_info:  u8  = buf[sym_p + SYM_INFO];
		let st_shndx: u16 = rdu16(buf, sym_p + SYM_SHNDX);
		let bind:     u32 = (st_info: u32) >> 4u32;
		// STB_GLOBAL = 1; defined in .text.
		if (bind == 1u32) {
			if (st_shndx != 0u16) {
				if ((st_shndx: i32) == idx_text) {
					let nm_p: *u8 = strtab + (st_name: u64);
					if (nm_p[0u64] != 0u8) {
						let nm: str = cstrtostr(a, nm_p);
						let de: *defent = amalloc(a, 32u64): *defent;
						de.name = nm;
						de.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 hdr_size: u64 = arfield(buf + pos + 48u64, 10u64);
		let hdr_end:  u64 = pos + 60u64;
		if (hdr_end + hdr_size > 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 = amalloc(l.a, 48u64): *armember;
			m.size = hdr_size;
			let mb: *u8 = amalloc(l.a, hdr_size): *u8;
			let i: u64 = 0u64;
			for (i < hdr_size) {
				mb[i] = buf[hdr_end + i];
				i += 1u64;
			};
			m.data = mb;
			m.defs = elfglobals(l.a, mb, hdr_size);
			m.loaded = 0;
			m.mnext = nil;
			if (head == nil) { head = m; }
			else { tail.mnext = m; };
			tail = m;
		}; }; };
		pos = hdr_end + hdr_size;
		if ((hdr_size & 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 = readall(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 shstr_sh_off: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
	let shstr: *u8 = buf + shstr_sh_off;

	// find .text, .symtab, .rela.text
	let idx_text:   i32 = -1;
	let idx_symtab: i32 = -1;
	let idx_rela:   i32 = -1;
	let i: u32 = 0u32;
	for (i < shnum) {
		let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE;
		let sh_type: u32 = rdu32(buf, sh_off + SHDR_TYPE);
		let sh_name: u32 = rdu32(buf, sh_off + SHDR_NAME);
		let nm: *u8 = shstr + (sh_name: u64);
		if (sh_type == SHT_PROGBITS: u32) {
			if (cstreq(nm, ".text")) { idx_text = i: i32; };
		};
		if (sh_type == SHT_SYMTAB: u32)  { idx_symtab = i: i32; };
		if (sh_type == SHT_RELA: u32) {
			if (cstreq(nm, ".rela.text")) { idx_rela = i: i32; };
		};
		i += 1u32;
	};
	if (idx_text < 0) {
		os.write(2, "w6l: missing .text\n".ptr, 18u64);
		return -1;
	};
	if (idx_symtab < 0) {
		os.write(2, "w6l: missing .symtab\n".ptr, 20u64);
		return -1;
	};

	let text_sh:   u64 = shoff + (idx_text: u64) * SHDR_SIZE;
	let text_off:  u64 = rdu64(buf, text_sh + SHDR_OFFSET);
	let text_size: u64 = rdu64(buf, text_sh + SHDR_SIZE_F);

	let sym_sh:   u64 = shoff + (idx_symtab: u64) * SHDR_SIZE;
	let sym_off:  u64 = rdu64(buf, sym_sh + SHDR_OFFSET);
	let sym_size: u64 = rdu64(buf, sym_sh + SHDR_SIZE_F);
	let sym_link: u32 = rdu32(buf, sym_sh + SHDR_LINK);
	let nsyms:    u64 = sym_size / SYM_SIZE;

	let str_sh:  u64 = shoff + (sym_link: u64) * SHDR_SIZE;
	let str_off: u64 = rdu64(buf, str_sh + SHDR_OFFSET);
	let strtab:  *u8 = buf + str_off;

	// Track this object.
	let ob: *lobj = amalloc(l.a, 64u64): *lobj;
	ob.path = cstrtostr(l.a, path);
	ob.buf = buf;
	ob.len = len;
	ob.textoff = l.textlen;
	ob.textsize = text_size;
	ob.onext = l.objs;
	l.objs = ob;

	// Append .text bytes to the combined image.
	emittext(l, buf + text_off, text_size);

	// 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 sym_p: u64 = sym_off + si * SYM_SIZE;
		let st_name:  u32 = rdu32(buf, sym_p + SYM_NAME);
		let st_shndx: u16 = rdu16(buf, sym_p + SYM_SHNDX);
		let st_value: u64 = rdu64(buf, sym_p + SYM_VALUE);
		let nm_p: *u8 = strtab + (st_name: u64);
		if (nm_p[0u64] != 0u8) {
			let nm: str = cstrtostr(l.a, nm_p);
			let gs: *lsym = intern(l, nm);
			if (st_shndx != 0u16) {
				if ((st_shndx: i32) == idx_text) {
					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 + st_value;
					};
				};
			};
		};
		si += 1u64;
	};

	// Per-object relocation collection.
	if (idx_rela >= 0) {
		let rela_sh:   u64 = shoff + (idx_rela: u64) * SHDR_SIZE;
		let rela_off:  u64 = rdu64(buf, rela_sh + SHDR_OFFSET);
		let rela_size: u64 = rdu64(buf, rela_sh + SHDR_SIZE_F);
		let nrel:      u64 = rela_size / RELA_SIZE;
		let ri: u64 = 0u64;
		for (ri < nrel) {
			let rp: u64 = rela_off + ri * RELA_SIZE;
			let r_off:    u64 = rdu64(buf, rp + RELA_OFFSET);
			let r_info:   u64 = rdu64(buf, rp + RELA_INFO);
			let r_addend: u64 = rdu64(buf, rp + RELA_ADDEND);
			let r_sym_idx: u32 = (r_info >> 32u64): u32;
			let r_kind:    i32 = ((r_info & 4294967295u64): u32): i32;
			let nr: *lrel = amalloc(l.a, 48u64): *lrel;
			nr.off = ob.textoff + r_off;
			nr.kind = r_kind;
			nr.addend = r_addend: i64;
			// Look up the referenced sym by name (re-walk symtab).
			if ((r_sym_idx: u64) < nsyms) {
				let s_p: u64 = sym_off + (r_sym_idx: u64) * SYM_SIZE;
				let s_name: u32 = rdu32(buf, s_p + SYM_NAME);
				let s_nm: *u8 = strtab + (s_name: u64);
				if (s_nm[0u64] != 0u8) {
					let nm: str = cstrtostr(l.a, s_nm);
					nr.sym = intern(l, nm);
				};
			};
			nr.rnext = l.rels;
			l.rels = nr;
			ri += 1u64;
		};
	};

	return 0;
};