// Port of cmd/w6l/out.c.

package main;

import os;
import rt;

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;

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

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 = alloc([], TEXT_OFF)!;
	hdr.len = TEXT_OFF: i32;

	// Ehdr (64 bytes).
	hdr[0u64] = 127u8;	// 0x7f
	hdr[1u64] = 'E';
	hdr[2u64] = 'L';
	hdr[3u64] = 'F';
	hdr[4u64] = ELFCLASS64;
	hdr[5u64] = ELFDATA2LSB;
	hdr[6u64] = EV_CURRENT: u8;
	wru16(hdr.ptr, 16u64, ET_EXEC);		// e_type
	wru16(hdr.ptr, 18u64, EM_X86_64_W);	// e_machine
	wru32(hdr.ptr, 20u64, EV_CURRENT);		// e_version
	wru64(hdr.ptr, 24u64, entry);		// e_entry
	wru64(hdr.ptr, 32u64, 64u64);		// e_phoff = sizeof(Ehdr)
	wru64(hdr.ptr, 40u64, 0u64);		// e_shoff
	wru32(hdr.ptr, 48u64, 0u32);		// e_flags
	wru16(hdr.ptr, 52u64, 64u16);		// e_ehsize
	wru16(hdr.ptr, 54u64, 56u16);		// e_phentsize
	if (hasdata) { wru16(hdr.ptr, 56u64, 2u16); }
	else { wru16(hdr.ptr, 56u64, 1u16); };
	wru16(hdr.ptr, 58u64, 0u16);		// e_shentsize
	wru16(hdr.ptr, 60u64, 0u16);		// e_shnum
	wru16(hdr.ptr, 62u64, 0u16);		// e_shstrndx

	// Phdr #1 (R+X) at offset 64.
	wru32(hdr.ptr, 64u64, PT_LOAD);
	wru32(hdr.ptr, 68u64, PF_R | PF_X);
	wru64(hdr.ptr, 72u64, 0u64);		// p_offset
	wru64(hdr.ptr, 80u64, base);		// p_vaddr
	wru64(hdr.ptr, 88u64, base);		// p_paddr
	wru64(hdr.ptr, 96u64, rxend);		// p_filesz
	// The loader page-rounds mappings; when present, dataoff starts
	// independently on the next page, so padding is not R+X extent.
	wru64(hdr.ptr, 104u64, rxend);		// p_memsz
	wru64(hdr.ptr, 112u64, TEXT_OFF);		// p_align

	if (hasdata) {
		// Phdr #2 (R+W) at offset 64+56=120.
		wru32(hdr.ptr, 120u64, PT_LOAD);
		wru32(hdr.ptr, 124u64, PF_R | PF_W);
		wru64(hdr.ptr, 128u64, dataoff);		// p_offset
		wru64(hdr.ptr, 136u64, base + dataoff);	// p_vaddr
		wru64(hdr.ptr, 144u64, base + dataoff);	// p_paddr
		wru64(hdr.ptr, 152u64, datafilelen);	// p_filesz
		wru64(hdr.ptr, 160u64, l.datalen);		// p_memsz
		wru64(hdr.ptr, 168u64, PAGE_SZ);		// p_align
	};

	let r1: (i64 | os.oserror) = os.writeall(fd, hdr.ptr, 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;
};