diff --git a/selfhost/cmd/w6l/dyn.ww b/selfhost/cmd/w6l/dyn.ww index f04593d1..b4570fe3 100644 --- a/selfhost/cmd/w6l/dyn.ww +++ b/selfhost/cmd/w6l/dyn.ww @@ -71,13 +71,13 @@ def VA_NEXT: u64 = 4u64; // ---- little-endian byte readers --------------------------------------- -fn d_u16(p: *u8, off: u64) u16 = { +fn du16(p: *u8, off: u64) u16 = { let b0: u16 = p[off]: u16; let b1: u16 = p[off + 1u64]: u16; return b0 | (b1 << 8u16); }; -fn d_u32(p: *u8, off: u64) u32 = { +fn du32(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; @@ -85,32 +85,32 @@ fn d_u32(p: *u8, off: u64) u32 = { return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32); }; -fn d_u64(p: *u8, off: u64) u64 = { - let lo: u64 = d_u32(p, off): u64; - let hi: u64 = d_u32(p, off + 4u64): u64; +fn du64(p: *u8, off: u64) u64 = { + let lo: u64 = du32(p, off): u64; + let hi: u64 = du32(p, off + 4u64): u64; return lo | (hi << 32u64); }; -fn d_i64(p: *u8, off: u64) i64 = { - return d_u64(p, off): i64; +fn di64(p: *u8, off: u64) i64 = { + return du64(p, off): i64; }; // ---- C-string helpers -------------------------------------------------- -fn d_cstrlen(p: *u8) u64 = { +fn dcstrlen(p: *u8) u64 = { let n: u64 = 0u64; for (p[n] != 0u8) { n += 1u64; }; return n; }; -fn d_cstr_to_str(a: *arena, p: *u8) str = { - let n: u64 = d_cstrlen(p); +fn dcstrtostr(a: *arena, p: *u8) str = { + let n: u64 = dcstrlen(p); return astrndup(a, p, n); }; // basename: scan for last '/' and return pointer past it. -fn d_basename(p: *u8) *u8 = { - let n: u64 = d_cstrlen(p); +fn dbasename(p: *u8) *u8 = { + let n: u64 = dcstrlen(p); let i: u64 = n; for (i > 0u64) { i -= 1u64; @@ -146,12 +146,12 @@ fn vdnameat(buf: *u8, verdef_off: u64, verdef_size: u64, let off: u64 = 0u64; for (off < verdef_size) { let vd_p: u64 = verdef_off + off; - let vd_ndx: u16 = d_u16(buf, vd_p + VD_NDX); - let vd_aux: u32 = d_u32(buf, vd_p + VD_AUX); - let vd_next: u32 = d_u32(buf, vd_p + VD_NEXT); + let vd_ndx: u16 = du16(buf, vd_p + VD_NDX); + let vd_aux: u32 = du32(buf, vd_p + VD_AUX); + let vd_next: u32 = du32(buf, vd_p + VD_NEXT); if (vd_ndx == ndx) { let aux_p: u64 = vd_p + (vd_aux: u64); - let vda_name: u32 = d_u32(buf, aux_p + VA_NAME); + let vda_name: u32 = du32(buf, aux_p + VA_NAME); return verstr + (vda_name: u64); }; if (vd_next == 0u32) { return nil; }; @@ -179,15 +179,15 @@ export fn loadso(l: *lnk, path: *u8) i32 = { if (buf[2u64] != 76u8) { return soerr("not ELF"); }; if (buf[3u64] != 70u8) { return soerr("not ELF"); }; if (buf[4u64] != 2u8) { return soerr("not ELFCLASS64"); }; - if (d_u16(buf, EH_EMACHINE) != EM_X86_64_SO) { + if (du16(buf, EH_EMACHINE) != EM_X86_64_SO) { return soerr("not amd64"); }; - if (d_u16(buf, EH_ETYPE) != ET_DYN_SO) { + if (du16(buf, EH_ETYPE) != ET_DYN_SO) { return soerr("not ET_DYN"); }; - let shoff: u64 = d_u64(buf, EH_SHOFF); - let shnum: u32 = d_u16(buf, EH_SHNUM): u32; + let shoff: u64 = du64(buf, EH_SHOFF); + let shnum: u32 = du16(buf, EH_SHNUM): u32; if (shoff == 0u64) { return soerr("stripped .so unsupported"); }; if (shnum == 0u32) { return soerr("stripped .so unsupported"); }; @@ -199,7 +199,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let i: u32 = 0u32; for (i < shnum) { let sh_p: u64 = shoff + (i: u64) * SH_SIZE; - let sh_type: u32 = d_u32(buf, sh_p + SH_TYPE); + let sh_type: u32 = du32(buf, sh_p + SH_TYPE); if (sh_type == SHT_DYNSYM) { idx_dynsym = i: i32; }; if (sh_type == SHT_DYNAMIC) { idx_dynamic = i: i32; }; if (sh_type == SHT_GNU_VERSYM) { idx_versym = i: i32; }; @@ -211,13 +211,13 @@ export fn loadso(l: *lnk, path: *u8) i32 = { }; let dynsym_sh: u64 = shoff + (idx_dynsym: u64) * SH_SIZE; - let dynsym_off: u64 = d_u64(buf, dynsym_sh + SH_OFFSET); - let dynsym_size: u64 = d_u64(buf, dynsym_sh + SH_SIZE_F); - let dynsym_link: u32 = d_u32(buf, dynsym_sh + SH_LINK); + let dynsym_off: u64 = du64(buf, dynsym_sh + SH_OFFSET); + let dynsym_size: u64 = du64(buf, dynsym_sh + SH_SIZE_F); + let dynsym_link: u32 = du32(buf, dynsym_sh + SH_LINK); let nsyms: u64 = dynsym_size / SY_SIZE; let dynstr_sh: u64 = shoff + (dynsym_link: u64) * SH_SIZE; - let dynstr_off: u64 = d_u64(buf, dynstr_sh + SH_OFFSET); + let dynstr_off: u64 = du64(buf, dynstr_sh + SH_OFFSET); let dynstr: *u8 = buf + dynstr_off; // SONAME: .dynamic strings live in the section pointed at by its @@ -225,22 +225,22 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let soname_cs: *u8 = nil; if (idx_dynamic >= 0) { let dyn_sh: u64 = shoff + (idx_dynamic: u64) * SH_SIZE; - let dyn_off: u64 = d_u64(buf, dyn_sh + SH_OFFSET); - let dyn_size: u64 = d_u64(buf, dyn_sh + SH_SIZE_F); - let dyn_link: u32 = d_u32(buf, dyn_sh + SH_LINK); + let dyn_off: u64 = du64(buf, dyn_sh + SH_OFFSET); + let dyn_size: u64 = du64(buf, dyn_sh + SH_SIZE_F); + let dyn_link: u32 = du32(buf, dyn_sh + SH_LINK); let dstr_sh: u64 = shoff + (dyn_link: u64) * SH_SIZE; - let dstr_off: u64 = d_u64(buf, dstr_sh + SH_OFFSET); + let dstr_off: u64 = du64(buf, dstr_sh + SH_OFFSET); let dstr: *u8 = buf + dstr_off; let nd: u64 = dyn_size / DY_SIZE; let di: u64 = 0u64; for (di < nd) { let d_p: u64 = dyn_off + di * DY_SIZE; - let d_tag: i64 = d_i64(buf, d_p + DY_TAG); + let d_tag: i64 = di64(buf, d_p + DY_TAG); if (d_tag == DT_NULL_TAG) { di = nd; // break } else { if (d_tag == DT_SONAME_TAG) { - let d_val: u64 = d_u64(buf, d_p + DY_VAL); + let d_val: u64 = du64(buf, d_p + DY_VAL); soname_cs = dstr + d_val; di = nd; // break } else { @@ -250,7 +250,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { }; }; if (soname_cs == nil) { - soname_cs = d_basename(path); + soname_cs = dbasename(path); }; // Versym is one u16 per dynsym entry. @@ -258,7 +258,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let has_versym: i32 = 0; if (idx_versym >= 0) { let vs_sh: u64 = shoff + (idx_versym: u64) * SH_SIZE; - versym_off = d_u64(buf, vs_sh + SH_OFFSET); + versym_off = du64(buf, vs_sh + SH_OFFSET); has_versym = 1; }; @@ -268,26 +268,26 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let verstr: *u8 = nil; if (idx_verdef >= 0) { let vd_sh: u64 = shoff + (idx_verdef: u64) * SH_SIZE; - verdef_off = d_u64(buf, vd_sh + SH_OFFSET); - verdef_size = d_u64(buf, vd_sh + SH_SIZE_F); - let vd_link: u32 = d_u32(buf, vd_sh + SH_LINK); + verdef_off = du64(buf, vd_sh + SH_OFFSET); + verdef_size = du64(buf, vd_sh + SH_SIZE_F); + let vd_link: u32 = du32(buf, vd_sh + SH_LINK); let vstr_sh: u64 = shoff + (vd_link: u64) * SH_SIZE; - let vstr_off: u64 = d_u64(buf, vstr_sh + SH_OFFSET); + let vstr_off: u64 = du64(buf, vstr_sh + SH_OFFSET); verstr = buf + vstr_off; }; // Build the lso. Exports are appended in dynsym order so // soprovides_v's first-match semantics match the C version. let so: *lso = amalloc(l.a, 64u64): *lso; - so.path = d_cstr_to_str(l.a, path); - so.soname = d_cstr_to_str(l.a, soname_cs); + so.path = dcstrtostr(l.a, path); + so.soname = dcstrtostr(l.a, soname_cs); so.exports = nil; let tail: *lexport = nil; let si: u64 = 1u64; for (si < nsyms) { let s_p: u64 = dynsym_off + si * SY_SIZE; - let st_shndx: u16 = d_u16(buf, s_p + SY_SHNDX); + let st_shndx: u16 = du16(buf, s_p + SY_SHNDX); if (st_shndx == 0u16) { si += 1u64; } else { let st_info: u8 = buf[s_p + SY_INFO]; let bind: u32 = (st_info: u32) >> 4u32; @@ -296,7 +296,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { si += 1u64; continue; }; }; - let st_name: u32 = d_u32(buf, s_p + SY_NAME); + let st_name: u32 = du32(buf, s_p + SY_NAME); let nm_p: *u8 = dynstr + (st_name: u64); if (nm_p[0u64] == 0u8) { si += 1u64; @@ -308,7 +308,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let vername_cs: *u8 = nil; let keep: i32 = 1; if (has_versym != 0) { - let v: u16 = d_u16(buf, versym_off + si * 2u64); + let v: u16 = du16(buf, versym_off + si * 2u64); if ((v & VERSYM_HIDDEN_C) != 0u16) { keep = 0; // non-default } else { @@ -334,12 +334,12 @@ export fn loadso(l: *lnk, path: *u8) i32 = { if (keep != 0) { let e: *lexport = amalloc(l.a, 48u64): *lexport; - e.name = d_cstr_to_str(l.a, nm_p); + e.name = dcstrtostr(l.a, nm_p); if (vername_cs == nil) { e.version.ptr = nil; e.version.len = 0i32; } else { - e.version = d_cstr_to_str(l.a, vername_cs); + e.version = dcstrtostr(l.a, vername_cs); }; e.enext = nil; if (tail == nil) { diff --git a/selfhost/cmd/w6l/dynout.ww b/selfhost/cmd/w6l/dynout.ww index 5d5ddee1..e6aadc5a 100644 --- a/selfhost/cmd/w6l/dynout.ww +++ b/selfhost/cmd/w6l/dynout.ww @@ -81,50 +81,50 @@ def PAGE: u64 = 4096u64; // The PT_INTERP literal. Returned via a fn to dodge `def : str = "..."` // breakage in the current cgen. -fn interp_str_v() str = { +fn interpstrv() str = { return "/lib64/ld-linux-x86-64.so.2"; }; // ---- byte writers ------------------------------------------------------ -fn d_wr8(buf: *u8, off: u64, v: u8) void = { +fn dwr8(buf: *u8, off: u64, v: u8) void = { buf[off] = v; }; -fn d_wr16(buf: *u8, off: u64, v: u16) void = { +fn dwr16(buf: *u8, off: u64, v: u16) void = { buf[off] = (v & 255u16): u8; buf[off + 1u64] = ((v >> 8u16) & 255u16): u8; }; -fn d_wr32(buf: *u8, off: u64, v: u32) void = { +fn dwr32(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 d_wr64(buf: *u8, off: u64, v: u64) void = { - d_wr32(buf, off, (v & 4294967295u64): u32); - d_wr32(buf, off + 4u64, ((v >> 32u64) & 4294967295u64): u32); +fn dwr64(buf: *u8, off: u64, v: u64) void = { + dwr32(buf, off, (v & 4294967295u64): u32); + dwr32(buf, off + 4u64, ((v >> 32u64) & 4294967295u64): u32); }; -fn d_wri64(buf: *u8, off: u64, v: i64) void = { - d_wr64(buf, off, v: u64); +fn dwri64(buf: *u8, off: u64, v: i64) void = { + dwr64(buf, off, v: u64); }; -fn d_wri32(buf: *u8, off: u64, v: i32) void = { - d_wr32(buf, off, v: u32); +fn dwri32(buf: *u8, off: u64, v: i32) void = { + dwr32(buf, off, v: u32); }; // ---- byte readers ------------------------------------------------------ -fn d_rd_u16(p: *u8, off: u64) u16 = { +fn drdu16(p: *u8, off: u64) u16 = { let b0: u16 = p[off]: u16; let b1: u16 = p[off + 1u64]: u16; return b0 | (b1 << 8u16); }; -fn d_rd_u32(p: *u8, off: u64) u32 = { +fn drdu32(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; @@ -132,11 +132,11 @@ fn d_rd_u32(p: *u8, off: u64) u32 = { return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32); }; -fn d_rd_i32(p: *u8, off: u64) i32 = { - return d_rd_u32(p, off): i32; +fn drdi32(p: *u8, off: u64) i32 = { + return drdu32(p, off): i32; }; -fn d_bcopy(dst: *u8, off: u64, src: *u8, n: u64) void = { +fn dbcopy(dst: *u8, off: u64, src: *u8, n: u64) void = { let i: u64 = 0u64; for (i < n) { dst[off + i] = src[i]; @@ -144,8 +144,8 @@ fn d_bcopy(dst: *u8, off: u64, src: *u8, n: u64) void = { }; }; -// elf_hash — SysV ELF hash. Used for .gnu.version_r's vna_hash. -fn elf_hash(name: str) u32 = { +// elfhash — SysV ELF hash. Used for .gnu.version_r's vna_hash. +fn elfhash(name: str) u32 = { let h: u32 = 0u32; let i: i32 = 0; for (i < name.len) { @@ -159,11 +159,11 @@ fn elf_hash(name: str) u32 = { return h; }; -fn align_up(off: u64, a: u64) u64 = { +fn alignup(off: u64, a: u64) u64 = { return (off + a - 1u64) & ~(a - 1u64); }; -fn str_eq_d(a: str, b: str) bool = { +fn streqd(a: str, b: str) bool = { if (a.len != b.len) { return false; }; let i: i32 = 0; for (i < a.len) { @@ -264,8 +264,8 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { } else { j += 1; }; }; if (has != 0) { - d_wr32(vlib_sos_idx_buf, (n_vlibs: u64) * 4u64, si: u32); - d_wr32(vlib_first_buf, (n_vlibs: u64) * 4u64, n_vers: u32); + dwr32(vlib_sos_idx_buf, (n_vlibs: u64) * 4u64, si: u32); + dwr32(vlib_first_buf, (n_vlibs: u64) * 4u64, n_vers: u32); let added: i32 = 0; let jj: i32 = 0; for (jj < n) { @@ -281,15 +281,15 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let kk: i32 = n_vers - added + k; let existing: str; existing.ptr = ver_name_ptr_arr[kk]; - existing.len = d_rd_i32(ver_name_len_buf, (kk: u64) * 4u64); - if (str_eq_d(existing, vname)) { + existing.len = drdi32(ver_name_len_buf, (kk: u64) * 4u64); + if (streqd(existing, vname)) { seen = 1; k = added; } else { k += 1; }; }; if (seen == 0) { - d_wr32(ver_lib_idx_buf, (n_vers: u64) * 4u64, n_vlibs: u32); + dwr32(ver_lib_idx_buf, (n_vers: u64) * 4u64, n_vlibs: u32); ver_name_ptr_arr[n_vers] = vname.ptr; - d_wri32(ver_name_len_buf, (n_vers: u64) * 4u64, vname.len); + dwri32(ver_name_len_buf, (n_vers: u64) * 4u64, vname.len); n_vers += 1; added += 1; }; @@ -297,7 +297,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; jj += 1; }; - d_wr32(vlib_count_buf, (n_vlibs: u64) * 4u64, added: u32); + dwr32(vlib_count_buf, (n_vlibs: u64) * 4u64, added: u32); n_vlibs += 1; }; si += 1; @@ -307,11 +307,11 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let next_vna: u16 = 2u16; let vi: i32 = 0; for (vi < n_vlibs) { - let first: i32 = d_rd_i32(vlib_first_buf, (vi: u64) * 4u64); - let cnt: i32 = d_rd_i32(vlib_count_buf, (vi: u64) * 4u64); + let first: i32 = drdi32(vlib_first_buf, (vi: u64) * 4u64); + let cnt: i32 = drdi32(vlib_count_buf, (vi: u64) * 4u64); let k: i32 = 0; for (k < cnt) { - d_wr16(ver_vna_other, ((first + k): u64) * 2u64, next_vna); + dwr16(ver_vna_other, ((first + k): u64) * 2u64, next_vna); next_vna += 1u16; k += 1; }; @@ -336,7 +336,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; pi = 0; for (pi < n_vers) { - let nm_len: i32 = d_rd_i32(ver_name_len_buf, (pi: u64) * 4u64); + let nm_len: i32 = drdi32(ver_name_len_buf, (pi: u64) * 4u64); dynstr_sz += nm_len: u64; dynstr_sz += 1u64; pi += 1; @@ -349,10 +349,10 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let soname_str: *u8 = amalloc(a, (nsos: u64) * 4u64): *u8; pi = 0; for (pi < nsos) { - d_wr32(soname_str, (pi: u64) * 4u64, dynstr_pos: u32); + dwr32(soname_str, (pi: u64) * 4u64, dynstr_pos: u32); let so2: *lso = sos_used[pi]; let snm: str = so2.soname; - d_bcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); + dbcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); dynstr_pos += snm.len: u64; dynstr[dynstr_pos] = 0u8; dynstr_pos += 1u64; @@ -361,10 +361,10 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let symname_str: *u8 = amalloc(a, nu * 4u64): *u8; pi = 0; for (pi < n) { - d_wr32(symname_str, (pi: u64) * 4u64, dynstr_pos: u32); + dwr32(symname_str, (pi: u64) * 4u64, dynstr_pos: u32); let dsm: *lsym = dynsyms[pi]; let snm: str = dsm.name; - d_bcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); + dbcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); dynstr_pos += snm.len: u64; dynstr[dynstr_pos] = 0u8; dynstr_pos += 1u64; @@ -372,10 +372,10 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; pi = 0; for (pi < n_vers) { - d_wr32(ver_dynstr_off, (pi: u64) * 4u64, dynstr_pos: u32); + dwr32(ver_dynstr_off, (pi: u64) * 4u64, dynstr_pos: u32); let nm_p: *u8 = ver_name_ptr_arr[pi]; - let nm_len: i32 = d_rd_i32(ver_name_len_buf, (pi: u64) * 4u64); - d_bcopy(dynstr, dynstr_pos, nm_p, nm_len: u64); + let nm_len: i32 = drdi32(ver_name_len_buf, (pi: u64) * 4u64); + dbcopy(dynstr, dynstr_pos, nm_p, nm_len: u64); dynstr_pos += nm_len: u64; dynstr[dynstr_pos] = 0u8; dynstr_pos += 1u64; @@ -391,27 +391,27 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let nm3: str = dsm3.name; let vname: str = soversion(dl3, nm3); if (vname.len == 0) { - d_wr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); + dwr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); } else { let matched: i32 = 0; let vk: i32 = 0; for (vk < n_vers) { - let vlx: i32 = d_rd_i32(ver_lib_idx_buf, (vk: u64) * 4u64); - let sosx: i32 = d_rd_i32(vlib_sos_idx_buf, (vlx: u64) * 4u64); + let vlx: i32 = drdi32(ver_lib_idx_buf, (vk: u64) * 4u64); + let sosx: i32 = drdi32(vlib_sos_idx_buf, (vlx: u64) * 4u64); if (sos_used[sosx] == dl3) { let exi: str; exi.ptr = ver_name_ptr_arr[vk]; - exi.len = d_rd_i32(ver_name_len_buf, (vk: u64) * 4u64); - if (str_eq_d(exi, vname)) { - let other: u16 = d_rd_u16(ver_vna_other, (vk: u64) * 2u64); - d_wr16(versym_for, (pi: u64) * 2u64, other); + exi.len = drdi32(ver_name_len_buf, (vk: u64) * 4u64); + if (streqd(exi, vname)) { + let other: u16 = drdu16(ver_vna_other, (vk: u64) * 2u64); + dwr16(versym_for, (pi: u64) * 2u64, other); matched = 1; vk = n_vers; } else { vk += 1; }; } else { vk += 1; }; }; if (matched == 0) { - d_wr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); + dwr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); }; }; pi += 1; @@ -421,7 +421,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let ehdr_sz: u64 = 64u64; let n_phdrs: u64 = 4u64; let phdr_sz: u64 = n_phdrs * 56u64; - let is_local: str = interp_str_v(); + let is_local: str = interpstrv(); let interp_sz: u64 = (is_local.len: u64) + 1u64; let nsyms_total: u64 = 1u64 + nu; @@ -439,7 +439,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let verneed_sz: u64 = 0u64; let vli: i32 = 0; for (vli < n_vlibs) { - let cnt: i32 = d_rd_i32(vlib_count_buf, (vli: u64) * 4u64); + let cnt: i32 = drdi32(vlib_count_buf, (vli: u64) * 4u64); verneed_sz += 16u64 + 16u64 * (cnt: u64); vli += 1; }; @@ -454,23 +454,23 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { // ---- compute file offsets ---- let off: u64 = ehdr_sz + phdr_sz; let interp_off: u64 = off; off += interp_sz; - off = align_up(off, 8u64); + off = alignup(off, 8u64); let dynstr_off: u64 = off; off += dynstr_sz; - off = align_up(off, 8u64); + off = alignup(off, 8u64); let dynsym_off: u64 = off; off += dynsym_sz; let hash_off: u64 = off; off += hash_sz; - off = align_up(off, 2u64); + off = alignup(off, 2u64); let versym_off: u64 = off; off += versym_sz; - off = align_up(off, 4u64); + off = alignup(off, 4u64); let verneed_off: u64 = off; off += verneed_sz; - off = align_up(off, 8u64); + off = alignup(off, 8u64); let relaplt_off: u64 = off; off += relaplt_sz; - let text_off: u64 = align_up(off, PAGE); + let text_off: u64 = alignup(off, PAGE); let plt_off: u64 = text_off + l.textlen; let rx_end: u64 = plt_off + plt_sz; - let gotplt_off: u64 = align_up(rx_end, PAGE); + let gotplt_off: u64 = alignup(rx_end, PAGE); let dynamic_off: u64 = gotplt_off + gotplt_sz; let file_end: u64 = dynamic_off + dynamic_sz; @@ -491,27 +491,27 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { pi = 0; for (pi < n) { let eoff: u64 = (1u64 + (pi: u64)) * 24u64; - d_wr32(dynsym_buf, eoff + 0u64, d_rd_u32(symname_str, (pi: u64) * 4u64)); - d_wr8(dynsym_buf, eoff + 4u64, (STB_GLOBAL_D << 4u8) | (STT_FUNC_D & 15u8)); - d_wr8(dynsym_buf, eoff + 5u64, 0u8); - d_wr16(dynsym_buf, eoff + 6u64, 0u16); - d_wr64(dynsym_buf, eoff + 8u64, 0u64); - d_wr64(dynsym_buf, eoff + 16u64, 0u64); + dwr32(dynsym_buf, eoff + 0u64, drdu32(symname_str, (pi: u64) * 4u64)); + dwr8(dynsym_buf, eoff + 4u64, (STB_GLOBAL_D << 4u8) | (STT_FUNC_D & 15u8)); + dwr8(dynsym_buf, eoff + 5u64, 0u8); + dwr16(dynsym_buf, eoff + 6u64, 0u16); + dwr64(dynsym_buf, eoff + 8u64, 0u64); + dwr64(dynsym_buf, eoff + 16u64, 0u64); pi += 1; }; // ---- build .hash (SysV, 1 bucket) ---- let hash_buf: *u8 = amalloc(a, hash_sz): *u8; - d_wr32(hash_buf, 0u64, nbuckets); - d_wr32(hash_buf, 4u64, nchain); + dwr32(hash_buf, 0u64, nbuckets); + dwr32(hash_buf, 4u64, nchain); let bucket0: u32 = 0u32; if (nsyms_total > 1u64) { bucket0 = 1u32; }; - d_wr32(hash_buf, 8u64, bucket0); + dwr32(hash_buf, 8u64, bucket0); let ci: u64 = 1u64; for (ci < nsyms_total) { let nxt: u32 = 0u32; if (ci + 1u64 < nsyms_total) { nxt = (ci + 1u64): u32; }; - d_wr32(hash_buf, 8u64 + (nbuckets: u64) * 4u64 + ci * 4u64, nxt); + dwr32(hash_buf, 8u64 + (nbuckets: u64) * 4u64 + ci * 4u64, nxt); ci += 1u64; }; @@ -520,19 +520,19 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { pi = 0; for (pi < n) { let roff: u64 = (pi: u64) * 24u64; - d_wr64(relaplt_buf, roff + 0u64, gotplt_va + (3u64 + (pi: u64)) * 8u64); + dwr64(relaplt_buf, roff + 0u64, gotplt_va + (3u64 + (pi: u64)) * 8u64); let info: u64 = ((1u64 + (pi: u64)) << 32u64) | (R_X86_64_JUMP_SLOT_D: u64); - d_wr64(relaplt_buf, roff + 8u64, info); - d_wri64(relaplt_buf, roff + 16u64, 0i64); + dwr64(relaplt_buf, roff + 8u64, info); + dwri64(relaplt_buf, roff + 16u64, 0i64); pi += 1; }; // ---- build .gnu.version (u16 per dynsym entry) ---- let versym_buf: *u8 = amalloc(a, versym_sz): *u8; - d_wr16(versym_buf, 0u64, VER_NDX_LOCAL_D); + dwr16(versym_buf, 0u64, VER_NDX_LOCAL_D); pi = 0; for (pi < n) { - d_wr16(versym_buf, 2u64 + (pi: u64) * 2u64, d_rd_u16(versym_for, (pi: u64) * 2u64)); + dwr16(versym_buf, 2u64 + (pi: u64) * 2u64, drdu16(versym_for, (pi: u64) * 2u64)); pi += 1; }; @@ -542,35 +542,35 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let vnoff: u64 = 0u64; vli = 0; for (vli < n_vlibs) { - let sos_idx: i32 = d_rd_i32(vlib_sos_idx_buf, (vli: u64) * 4u64); - let first: i32 = d_rd_i32(vlib_first_buf, (vli: u64) * 4u64); - let cnt: i32 = d_rd_i32(vlib_count_buf, (vli: u64) * 4u64); + let sos_idx: i32 = drdi32(vlib_sos_idx_buf, (vli: u64) * 4u64); + let first: i32 = drdi32(vlib_first_buf, (vli: u64) * 4u64); + let cnt: i32 = drdi32(vlib_count_buf, (vli: u64) * 4u64); let vn_start: u64 = vnoff; - d_wr16(verneed_buf, vnoff + 0u64, 1u16); - d_wr16(verneed_buf, vnoff + 2u64, cnt: u16); - d_wr32(verneed_buf, vnoff + 4u64, d_rd_u32(soname_str, (sos_idx: u64) * 4u64)); - d_wr32(verneed_buf, vnoff + 8u64, 16u32); + dwr16(verneed_buf, vnoff + 0u64, 1u16); + dwr16(verneed_buf, vnoff + 2u64, cnt: u16); + dwr32(verneed_buf, vnoff + 4u64, drdu32(soname_str, (sos_idx: u64) * 4u64)); + dwr32(verneed_buf, vnoff + 8u64, 16u32); vnoff += 16u64; let k: i32 = 0; for (k < cnt) { let vk: i32 = first + k; let nm: str; nm.ptr = ver_name_ptr_arr[vk]; - nm.len = d_rd_i32(ver_name_len_buf, (vk: u64) * 4u64); - let h: u32 = elf_hash(nm); - d_wr32(verneed_buf, vnoff + 0u64, h); - d_wr16(verneed_buf, vnoff + 4u64, 0u16); - d_wr16(verneed_buf, vnoff + 6u64, d_rd_u16(ver_vna_other, (vk: u64) * 2u64)); - d_wr32(verneed_buf, vnoff + 8u64, d_rd_u32(ver_dynstr_off, (vk: u64) * 4u64)); + nm.len = drdi32(ver_name_len_buf, (vk: u64) * 4u64); + let h: u32 = elfhash(nm); + dwr32(verneed_buf, vnoff + 0u64, h); + dwr16(verneed_buf, vnoff + 4u64, 0u16); + dwr16(verneed_buf, vnoff + 6u64, drdu16(ver_vna_other, (vk: u64) * 2u64)); + dwr32(verneed_buf, vnoff + 8u64, drdu32(ver_dynstr_off, (vk: u64) * 4u64)); let nxt: u32 = 0u32; if (k + 1 < cnt) { nxt = 16u32; }; - d_wr32(verneed_buf, vnoff + 12u64, nxt); + dwr32(verneed_buf, vnoff + 12u64, nxt); vnoff += 16u64; k += 1; }; let vn_nxt: u32 = 0u32; if (vli + 1 < n_vlibs) { vn_nxt = (vnoff - vn_start): u32; }; - d_wr32(verneed_buf, vn_start + 12u64, vn_nxt); + dwr32(verneed_buf, vn_start + 12u64, vn_nxt); vli += 1; }; }; @@ -584,42 +584,42 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let next_ip: u64 = stub_va + 6u64; let slot_va: u64 = gotplt_va + (3u64 + (pi: u64)) * 8u64; let disp: i64 = (slot_va: i64) - (next_ip: i64); - d_wr8(plt_buf, p_off + 0u64, 255u8); - d_wr8(plt_buf, p_off + 1u64, 37u8); - d_wr32(plt_buf, p_off + 2u64, (disp: i32): u32); + dwr8(plt_buf, p_off + 0u64, 255u8); + dwr8(plt_buf, p_off + 1u64, 37u8); + dwr32(plt_buf, p_off + 2u64, (disp: i32): u32); pi += 1; }; // ---- build .got.plt ---- let gotplt_buf: *u8 = amalloc(a, gotplt_sz): *u8; - d_wr64(gotplt_buf, 0u64, dynamic_va); + dwr64(gotplt_buf, 0u64, dynamic_va); // ---- build .dynamic ---- let dynamic_buf: *u8 = amalloc(a, dynamic_sz): *u8; let dk: u64 = 0u64; pi = 0; for (pi < nsos) { - d_wri64(dynamic_buf, dk * 16u64 + 0u64, DT_NEEDED); - d_wr64(dynamic_buf, dk * 16u64 + 8u64, d_rd_u32(soname_str, (pi: u64) * 4u64): u64); + dwri64(dynamic_buf, dk * 16u64 + 0u64, DT_NEEDED); + dwr64(dynamic_buf, dk * 16u64 + 8u64, drdu32(soname_str, (pi: u64) * 4u64): u64); dk += 1u64; pi += 1; }; - d_wri64(dynamic_buf, dk * 16u64, DT_HASH); d_wr64(dynamic_buf, dk * 16u64 + 8u64, hash_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_STRTAB); d_wr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_SYMTAB); d_wr64(dynamic_buf, dk * 16u64 + 8u64, dynsym_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_STRSZ); d_wr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_sz); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_SYMENT); d_wr64(dynamic_buf, dk * 16u64 + 8u64, 24u64); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_PLTGOT); d_wr64(dynamic_buf, dk * 16u64 + 8u64, gotplt_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_PLTRELSZ); d_wr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_sz); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_PLTREL); d_wr64(dynamic_buf, dk * 16u64 + 8u64, DT_RELA: u64);dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_JMPREL); d_wr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_BIND_NOW); d_wr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_HASH); dwr64(dynamic_buf, dk * 16u64 + 8u64, hash_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_STRTAB); dwr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_SYMTAB); dwr64(dynamic_buf, dk * 16u64 + 8u64, dynsym_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_STRSZ); dwr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_sz); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_SYMENT); dwr64(dynamic_buf, dk * 16u64 + 8u64, 24u64); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_PLTGOT); dwr64(dynamic_buf, dk * 16u64 + 8u64, gotplt_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_PLTRELSZ); dwr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_sz); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_PLTREL); dwr64(dynamic_buf, dk * 16u64 + 8u64, DT_RELA: u64);dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_JMPREL); dwr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_BIND_NOW); dwr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; if (with_ver != 0) { - d_wri64(dynamic_buf, dk * 16u64, DT_VERSYM); d_wr64(dynamic_buf, dk * 16u64 + 8u64, versym_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_VERNEED); d_wr64(dynamic_buf, dk * 16u64 + 8u64, verneed_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_VERNEEDNUM); d_wr64(dynamic_buf, dk * 16u64 + 8u64, n_vlibs: u64);dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_VERSYM); dwr64(dynamic_buf, dk * 16u64 + 8u64, versym_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_VERNEED); dwr64(dynamic_buf, dk * 16u64 + 8u64, verneed_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_VERNEEDNUM); dwr64(dynamic_buf, dk * 16u64 + 8u64, n_vlibs: u64);dk += 1u64; }; - d_wri64(dynamic_buf, dk * 16u64, DT_NULL); d_wr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_NULL); dwr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; if (dk != ndyn) { os.write(2, "w6l: dynamic entry count mismatch\n".ptr, 33u64); return 1; @@ -640,7 +640,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let site: u64 = text_va + r.off; let stub: u64 = plt_va + (rsym.pltidx: u64) * PLT_STUB_BYTES_D; let disp: i64 = (stub: i64) - (site: i64) + r.addend; - d_wr32(l.text, r.off, (disp: i32): u32); + dwr32(l.text, r.off, (disp: i32): u32); }; }; r = r.rnext; @@ -654,86 +654,86 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; // Ehdr - d_wr8(file_buf, 0u64, 127u8); - d_wr8(file_buf, 1u64, 69u8); - d_wr8(file_buf, 2u64, 76u8); - d_wr8(file_buf, 3u64, 70u8); - d_wr8(file_buf, 4u64, ELFCLASS64_D); - d_wr8(file_buf, 5u64, ELFDATA2LSB_D); - d_wr8(file_buf, 6u64, EV_CURRENT_D: u8); - d_wr16(file_buf, 16u64, ET_EXEC_D); - d_wr16(file_buf, 18u64, EM_X86_64_D); - d_wr32(file_buf, 20u64, EV_CURRENT_D); - d_wr64(file_buf, 24u64, entry); - d_wr64(file_buf, 32u64, ehdr_sz); - d_wr64(file_buf, 40u64, 0u64); - d_wr32(file_buf, 48u64, 0u32); - d_wr16(file_buf, 52u64, ehdr_sz: u16); - d_wr16(file_buf, 54u64, 56u16); - d_wr16(file_buf, 56u64, n_phdrs: u16); - d_wr16(file_buf, 58u64, 0u16); - d_wr16(file_buf, 60u64, 0u16); - d_wr16(file_buf, 62u64, 0u16); + dwr8(file_buf, 0u64, 127u8); + dwr8(file_buf, 1u64, 69u8); + dwr8(file_buf, 2u64, 76u8); + dwr8(file_buf, 3u64, 70u8); + dwr8(file_buf, 4u64, ELFCLASS64_D); + dwr8(file_buf, 5u64, ELFDATA2LSB_D); + dwr8(file_buf, 6u64, EV_CURRENT_D: u8); + dwr16(file_buf, 16u64, ET_EXEC_D); + dwr16(file_buf, 18u64, EM_X86_64_D); + dwr32(file_buf, 20u64, EV_CURRENT_D); + dwr64(file_buf, 24u64, entry); + dwr64(file_buf, 32u64, ehdr_sz); + dwr64(file_buf, 40u64, 0u64); + dwr32(file_buf, 48u64, 0u32); + dwr16(file_buf, 52u64, ehdr_sz: u16); + dwr16(file_buf, 54u64, 56u16); + dwr16(file_buf, 56u64, n_phdrs: u16); + dwr16(file_buf, 58u64, 0u16); + dwr16(file_buf, 60u64, 0u16); + dwr16(file_buf, 62u64, 0u16); // Phdrs at offset 64. let p0: u64 = 64u64; - d_wr32(file_buf, p0 + 0u64, PT_LOAD_D); - d_wr32(file_buf, p0 + 4u64, PF_R_D | PF_X_D); - d_wr64(file_buf, p0 + 8u64, 0u64); - d_wr64(file_buf, p0 + 16u64, base); - d_wr64(file_buf, p0 + 24u64, base); - d_wr64(file_buf, p0 + 32u64, rx_end); - d_wr64(file_buf, p0 + 40u64, rx_end); - d_wr64(file_buf, p0 + 48u64, PAGE); + dwr32(file_buf, p0 + 0u64, PT_LOAD_D); + dwr32(file_buf, p0 + 4u64, PF_R_D | PF_X_D); + dwr64(file_buf, p0 + 8u64, 0u64); + dwr64(file_buf, p0 + 16u64, base); + dwr64(file_buf, p0 + 24u64, base); + dwr64(file_buf, p0 + 32u64, rx_end); + dwr64(file_buf, p0 + 40u64, rx_end); + dwr64(file_buf, p0 + 48u64, PAGE); let p1: u64 = 64u64 + 56u64; - d_wr32(file_buf, p1 + 0u64, PT_LOAD_D); - d_wr32(file_buf, p1 + 4u64, PF_R_D | PF_W_D); - d_wr64(file_buf, p1 + 8u64, gotplt_off); - d_wr64(file_buf, p1 + 16u64, gotplt_va); - d_wr64(file_buf, p1 + 24u64, gotplt_va); - d_wr64(file_buf, p1 + 32u64, file_end - gotplt_off); - d_wr64(file_buf, p1 + 40u64, file_end - gotplt_off); - d_wr64(file_buf, p1 + 48u64, PAGE); + dwr32(file_buf, p1 + 0u64, PT_LOAD_D); + dwr32(file_buf, p1 + 4u64, PF_R_D | PF_W_D); + dwr64(file_buf, p1 + 8u64, gotplt_off); + dwr64(file_buf, p1 + 16u64, gotplt_va); + dwr64(file_buf, p1 + 24u64, gotplt_va); + dwr64(file_buf, p1 + 32u64, file_end - gotplt_off); + dwr64(file_buf, p1 + 40u64, file_end - gotplt_off); + dwr64(file_buf, p1 + 48u64, PAGE); let p2: u64 = 64u64 + 112u64; - d_wr32(file_buf, p2 + 0u64, PT_INTERP_D); - d_wr32(file_buf, p2 + 4u64, PF_R_D); - d_wr64(file_buf, p2 + 8u64, interp_off); - d_wr64(file_buf, p2 + 16u64, interp_va); - d_wr64(file_buf, p2 + 24u64, interp_va); - d_wr64(file_buf, p2 + 32u64, interp_sz); - d_wr64(file_buf, p2 + 40u64, interp_sz); - d_wr64(file_buf, p2 + 48u64, 1u64); + dwr32(file_buf, p2 + 0u64, PT_INTERP_D); + dwr32(file_buf, p2 + 4u64, PF_R_D); + dwr64(file_buf, p2 + 8u64, interp_off); + dwr64(file_buf, p2 + 16u64, interp_va); + dwr64(file_buf, p2 + 24u64, interp_va); + dwr64(file_buf, p2 + 32u64, interp_sz); + dwr64(file_buf, p2 + 40u64, interp_sz); + dwr64(file_buf, p2 + 48u64, 1u64); let p3: u64 = 64u64 + 168u64; - d_wr32(file_buf, p3 + 0u64, PT_DYNAMIC_D); - d_wr32(file_buf, p3 + 4u64, PF_R_D | PF_W_D); - d_wr64(file_buf, p3 + 8u64, dynamic_off); - d_wr64(file_buf, p3 + 16u64, dynamic_va); - d_wr64(file_buf, p3 + 24u64, dynamic_va); - d_wr64(file_buf, p3 + 32u64, dynamic_sz); - d_wr64(file_buf, p3 + 40u64, dynamic_sz); - d_wr64(file_buf, p3 + 48u64, 8u64); + dwr32(file_buf, p3 + 0u64, PT_DYNAMIC_D); + dwr32(file_buf, p3 + 4u64, PF_R_D | PF_W_D); + dwr64(file_buf, p3 + 8u64, dynamic_off); + dwr64(file_buf, p3 + 16u64, dynamic_va); + dwr64(file_buf, p3 + 24u64, dynamic_va); + dwr64(file_buf, p3 + 32u64, dynamic_sz); + dwr64(file_buf, p3 + 40u64, dynamic_sz); + dwr64(file_buf, p3 + 48u64, 8u64); // Sections. - let interp_local: str = interp_str_v(); - d_bcopy(file_buf, interp_off, interp_local.ptr, interp_local.len: u64); - d_wr8(file_buf, interp_off + (interp_local.len: u64), 0u8); - d_bcopy(file_buf, dynstr_off, dynstr, dynstr_sz); - d_bcopy(file_buf, dynsym_off, dynsym_buf, dynsym_sz); - d_bcopy(file_buf, hash_off, hash_buf, hash_sz); - d_bcopy(file_buf, versym_off, versym_buf, versym_sz); + let interp_local: str = interpstrv(); + dbcopy(file_buf, interp_off, interp_local.ptr, interp_local.len: u64); + dwr8(file_buf, interp_off + (interp_local.len: u64), 0u8); + dbcopy(file_buf, dynstr_off, dynstr, dynstr_sz); + dbcopy(file_buf, dynsym_off, dynsym_buf, dynsym_sz); + dbcopy(file_buf, hash_off, hash_buf, hash_sz); + dbcopy(file_buf, versym_off, versym_buf, versym_sz); if (verneed_sz > 0u64) { - d_bcopy(file_buf, verneed_off, verneed_buf, verneed_sz); + dbcopy(file_buf, verneed_off, verneed_buf, verneed_sz); }; - d_bcopy(file_buf, relaplt_off, relaplt_buf, relaplt_sz); + dbcopy(file_buf, relaplt_off, relaplt_buf, relaplt_sz); if (l.textlen > 0u64) { - d_bcopy(file_buf, text_off, l.text, l.textlen); + dbcopy(file_buf, text_off, l.text, l.textlen); }; - d_bcopy(file_buf, plt_off, plt_buf, plt_sz); - d_bcopy(file_buf, gotplt_off, gotplt_buf, gotplt_sz); - d_bcopy(file_buf, dynamic_off, dynamic_buf, dynamic_sz); + dbcopy(file_buf, plt_off, plt_buf, plt_sz); + dbcopy(file_buf, gotplt_off, gotplt_buf, gotplt_sz); + dbcopy(file_buf, dynamic_off, dynamic_buf, dynamic_sz); let wrote: i64 = os.writefull(fd, file_buf, file_end); if (wrote != file_end: i64) { diff --git a/selfhost/cmd/w6l/main.combined.ww b/selfhost/cmd/w6l/main.combined.ww index 15e551f2..155e553d 100644 --- a/selfhost/cmd/w6l/main.combined.ww +++ b/selfhost/cmd/w6l/main.combined.ww @@ -441,13 +441,13 @@ def SHT_RELA: i32 = 4; // 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 rd_u16(p: *u8, off: u64) u16 = { +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 rd_u32(p: *u8, off: u64) u32 = { +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; @@ -455,9 +455,9 @@ fn rd_u32(p: *u8, off: u64) u32 = { return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32); }; -fn rd_u64(p: *u8, off: u64) u64 = { - let lo: u64 = rd_u32(p, off): u64; - let hi: u64 = rd_u32(p, off + 4u64): u64; +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); }; @@ -614,11 +614,11 @@ fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = { if (buf[2u64] != 76u8) { return nil; }; if (buf[3u64] != 70u8) { return nil; }; - let shoff: u64 = rd_u64(buf, EHDR_SHOFF); - let shnum: u32 = rd_u16(buf, EHDR_SHNUM): u32; - let shstrndx: u32 = rd_u16(buf, EHDR_SHSTRNDX): u32; + 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 = rd_u64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET); + 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; @@ -626,8 +626,8 @@ fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = { let i: u32 = 0u32; for (i < shnum) { let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE; - let sh_type: u32 = rd_u32(buf, sh_off + SHDR_TYPE); - let sh_name: u32 = rd_u32(buf, sh_off + SHDR_NAME); + 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; }; @@ -639,22 +639,22 @@ fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = { if (idx_symtab < 0) { return nil; }; let sym_sh: u64 = shoff + (idx_symtab: u64) * SHDR_SIZE; - let sym_off: u64 = rd_u64(buf, sym_sh + SHDR_OFFSET); - let sym_size: u64 = rd_u64(buf, sym_sh + SHDR_SIZE_F); - let sym_link: u32 = rd_u32(buf, sym_sh + SHDR_LINK); + 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 = rd_u64(buf, str_sh + SHDR_OFFSET); + 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 = rd_u32(buf, sym_p + SYM_NAME); + let st_name: u32 = rdu32(buf, sym_p + SYM_NAME); let st_info: u8 = buf[sym_p + SYM_INFO]; - let st_shndx: u16 = rd_u16(buf, sym_p + SYM_SHNDX); + 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) { @@ -771,14 +771,14 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { if (buf[2u64] != 76u8) { return -1; }; if (buf[3u64] != 70u8) { return -1; }; if (buf[4u64] != 2u8) { return -1; }; // ELFCLASS64 - if (rd_u16(buf, EHDR_TYPE) != ET_REL: u16) { return -1; }; - if (rd_u16(buf, EHDR_MACHINE) != EM_X86_64: u16) { return -1; }; + if (rdu16(buf, EHDR_TYPE) != ET_REL: u16) { return -1; }; + if (rdu16(buf, EHDR_MACHINE) != EM_X86_64: u16) { return -1; }; - let shoff: u64 = rd_u64(buf, EHDR_SHOFF); - let shnum: u32 = rd_u16(buf, EHDR_SHNUM): u32; - let shstrndx: u32 = rd_u16(buf, EHDR_SHSTRNDX): u32; + 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 = rd_u64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET); + 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 @@ -788,8 +788,8 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { let i: u32 = 0u32; for (i < shnum) { let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE; - let sh_type: u32 = rd_u32(buf, sh_off + SHDR_TYPE); - let sh_name: u32 = rd_u32(buf, sh_off + SHDR_NAME); + 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; }; @@ -810,17 +810,17 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { }; let text_sh: u64 = shoff + (idx_text: u64) * SHDR_SIZE; - let text_off: u64 = rd_u64(buf, text_sh + SHDR_OFFSET); - let text_size: u64 = rd_u64(buf, text_sh + SHDR_SIZE_F); + 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 = rd_u64(buf, sym_sh + SHDR_OFFSET); - let sym_size: u64 = rd_u64(buf, sym_sh + SHDR_SIZE_F); - let sym_link: u32 = rd_u32(buf, sym_sh + SHDR_LINK); + 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 = rd_u64(buf, str_sh + SHDR_OFFSET); + let str_off: u64 = rdu64(buf, str_sh + SHDR_OFFSET); let strtab: *u8 = buf + str_off; // Track this object. @@ -842,9 +842,9 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { 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 = rd_u32(buf, sym_p + SYM_NAME); - let st_shndx: u16 = rd_u16(buf, sym_p + SYM_SHNDX); - let st_value: u64 = rd_u64(buf, sym_p + SYM_VALUE); + 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); @@ -869,15 +869,15 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { // Per-object relocation collection. if (idx_rela >= 0) { let rela_sh: u64 = shoff + (idx_rela: u64) * SHDR_SIZE; - let rela_off: u64 = rd_u64(buf, rela_sh + SHDR_OFFSET); - let rela_size: u64 = rd_u64(buf, rela_sh + SHDR_SIZE_F); + 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 = rd_u64(buf, rp + RELA_OFFSET); - let r_info: u64 = rd_u64(buf, rp + RELA_INFO); - let r_addend: u64 = rd_u64(buf, rp + RELA_ADDEND); + 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; @@ -887,7 +887,7 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { // 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 = rd_u32(buf, s_p + SYM_NAME); + 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); @@ -976,13 +976,13 @@ def VA_NEXT: u64 = 4u64; // ---- little-endian byte readers --------------------------------------- -fn d_u16(p: *u8, off: u64) u16 = { +fn du16(p: *u8, off: u64) u16 = { let b0: u16 = p[off]: u16; let b1: u16 = p[off + 1u64]: u16; return b0 | (b1 << 8u16); }; -fn d_u32(p: *u8, off: u64) u32 = { +fn du32(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; @@ -990,32 +990,32 @@ fn d_u32(p: *u8, off: u64) u32 = { return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32); }; -fn d_u64(p: *u8, off: u64) u64 = { - let lo: u64 = d_u32(p, off): u64; - let hi: u64 = d_u32(p, off + 4u64): u64; +fn du64(p: *u8, off: u64) u64 = { + let lo: u64 = du32(p, off): u64; + let hi: u64 = du32(p, off + 4u64): u64; return lo | (hi << 32u64); }; -fn d_i64(p: *u8, off: u64) i64 = { - return d_u64(p, off): i64; +fn di64(p: *u8, off: u64) i64 = { + return du64(p, off): i64; }; // ---- C-string helpers -------------------------------------------------- -fn d_cstrlen(p: *u8) u64 = { +fn dcstrlen(p: *u8) u64 = { let n: u64 = 0u64; for (p[n] != 0u8) { n += 1u64; }; return n; }; -fn d_cstr_to_str(a: *arena, p: *u8) str = { - let n: u64 = d_cstrlen(p); +fn dcstrtostr(a: *arena, p: *u8) str = { + let n: u64 = dcstrlen(p); return astrndup(a, p, n); }; // basename: scan for last '/' and return pointer past it. -fn d_basename(p: *u8) *u8 = { - let n: u64 = d_cstrlen(p); +fn dbasename(p: *u8) *u8 = { + let n: u64 = dcstrlen(p); let i: u64 = n; for (i > 0u64) { i -= 1u64; @@ -1051,12 +1051,12 @@ fn vdnameat(buf: *u8, verdef_off: u64, verdef_size: u64, let off: u64 = 0u64; for (off < verdef_size) { let vd_p: u64 = verdef_off + off; - let vd_ndx: u16 = d_u16(buf, vd_p + VD_NDX); - let vd_aux: u32 = d_u32(buf, vd_p + VD_AUX); - let vd_next: u32 = d_u32(buf, vd_p + VD_NEXT); + let vd_ndx: u16 = du16(buf, vd_p + VD_NDX); + let vd_aux: u32 = du32(buf, vd_p + VD_AUX); + let vd_next: u32 = du32(buf, vd_p + VD_NEXT); if (vd_ndx == ndx) { let aux_p: u64 = vd_p + (vd_aux: u64); - let vda_name: u32 = d_u32(buf, aux_p + VA_NAME); + let vda_name: u32 = du32(buf, aux_p + VA_NAME); return verstr + (vda_name: u64); }; if (vd_next == 0u32) { return nil; }; @@ -1084,15 +1084,15 @@ export fn loadso(l: *lnk, path: *u8) i32 = { if (buf[2u64] != 76u8) { return soerr("not ELF"); }; if (buf[3u64] != 70u8) { return soerr("not ELF"); }; if (buf[4u64] != 2u8) { return soerr("not ELFCLASS64"); }; - if (d_u16(buf, EH_EMACHINE) != EM_X86_64_SO) { + if (du16(buf, EH_EMACHINE) != EM_X86_64_SO) { return soerr("not amd64"); }; - if (d_u16(buf, EH_ETYPE) != ET_DYN_SO) { + if (du16(buf, EH_ETYPE) != ET_DYN_SO) { return soerr("not ET_DYN"); }; - let shoff: u64 = d_u64(buf, EH_SHOFF); - let shnum: u32 = d_u16(buf, EH_SHNUM): u32; + let shoff: u64 = du64(buf, EH_SHOFF); + let shnum: u32 = du16(buf, EH_SHNUM): u32; if (shoff == 0u64) { return soerr("stripped .so unsupported"); }; if (shnum == 0u32) { return soerr("stripped .so unsupported"); }; @@ -1104,7 +1104,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let i: u32 = 0u32; for (i < shnum) { let sh_p: u64 = shoff + (i: u64) * SH_SIZE; - let sh_type: u32 = d_u32(buf, sh_p + SH_TYPE); + let sh_type: u32 = du32(buf, sh_p + SH_TYPE); if (sh_type == SHT_DYNSYM) { idx_dynsym = i: i32; }; if (sh_type == SHT_DYNAMIC) { idx_dynamic = i: i32; }; if (sh_type == SHT_GNU_VERSYM) { idx_versym = i: i32; }; @@ -1116,13 +1116,13 @@ export fn loadso(l: *lnk, path: *u8) i32 = { }; let dynsym_sh: u64 = shoff + (idx_dynsym: u64) * SH_SIZE; - let dynsym_off: u64 = d_u64(buf, dynsym_sh + SH_OFFSET); - let dynsym_size: u64 = d_u64(buf, dynsym_sh + SH_SIZE_F); - let dynsym_link: u32 = d_u32(buf, dynsym_sh + SH_LINK); + let dynsym_off: u64 = du64(buf, dynsym_sh + SH_OFFSET); + let dynsym_size: u64 = du64(buf, dynsym_sh + SH_SIZE_F); + let dynsym_link: u32 = du32(buf, dynsym_sh + SH_LINK); let nsyms: u64 = dynsym_size / SY_SIZE; let dynstr_sh: u64 = shoff + (dynsym_link: u64) * SH_SIZE; - let dynstr_off: u64 = d_u64(buf, dynstr_sh + SH_OFFSET); + let dynstr_off: u64 = du64(buf, dynstr_sh + SH_OFFSET); let dynstr: *u8 = buf + dynstr_off; // SONAME: .dynamic strings live in the section pointed at by its @@ -1130,22 +1130,22 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let soname_cs: *u8 = nil; if (idx_dynamic >= 0) { let dyn_sh: u64 = shoff + (idx_dynamic: u64) * SH_SIZE; - let dyn_off: u64 = d_u64(buf, dyn_sh + SH_OFFSET); - let dyn_size: u64 = d_u64(buf, dyn_sh + SH_SIZE_F); - let dyn_link: u32 = d_u32(buf, dyn_sh + SH_LINK); + let dyn_off: u64 = du64(buf, dyn_sh + SH_OFFSET); + let dyn_size: u64 = du64(buf, dyn_sh + SH_SIZE_F); + let dyn_link: u32 = du32(buf, dyn_sh + SH_LINK); let dstr_sh: u64 = shoff + (dyn_link: u64) * SH_SIZE; - let dstr_off: u64 = d_u64(buf, dstr_sh + SH_OFFSET); + let dstr_off: u64 = du64(buf, dstr_sh + SH_OFFSET); let dstr: *u8 = buf + dstr_off; let nd: u64 = dyn_size / DY_SIZE; let di: u64 = 0u64; for (di < nd) { let d_p: u64 = dyn_off + di * DY_SIZE; - let d_tag: i64 = d_i64(buf, d_p + DY_TAG); + let d_tag: i64 = di64(buf, d_p + DY_TAG); if (d_tag == DT_NULL_TAG) { di = nd; // break } else { if (d_tag == DT_SONAME_TAG) { - let d_val: u64 = d_u64(buf, d_p + DY_VAL); + let d_val: u64 = du64(buf, d_p + DY_VAL); soname_cs = dstr + d_val; di = nd; // break } else { @@ -1155,7 +1155,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { }; }; if (soname_cs == nil) { - soname_cs = d_basename(path); + soname_cs = dbasename(path); }; // Versym is one u16 per dynsym entry. @@ -1163,7 +1163,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let has_versym: i32 = 0; if (idx_versym >= 0) { let vs_sh: u64 = shoff + (idx_versym: u64) * SH_SIZE; - versym_off = d_u64(buf, vs_sh + SH_OFFSET); + versym_off = du64(buf, vs_sh + SH_OFFSET); has_versym = 1; }; @@ -1173,26 +1173,26 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let verstr: *u8 = nil; if (idx_verdef >= 0) { let vd_sh: u64 = shoff + (idx_verdef: u64) * SH_SIZE; - verdef_off = d_u64(buf, vd_sh + SH_OFFSET); - verdef_size = d_u64(buf, vd_sh + SH_SIZE_F); - let vd_link: u32 = d_u32(buf, vd_sh + SH_LINK); + verdef_off = du64(buf, vd_sh + SH_OFFSET); + verdef_size = du64(buf, vd_sh + SH_SIZE_F); + let vd_link: u32 = du32(buf, vd_sh + SH_LINK); let vstr_sh: u64 = shoff + (vd_link: u64) * SH_SIZE; - let vstr_off: u64 = d_u64(buf, vstr_sh + SH_OFFSET); + let vstr_off: u64 = du64(buf, vstr_sh + SH_OFFSET); verstr = buf + vstr_off; }; // Build the lso. Exports are appended in dynsym order so // soprovides_v's first-match semantics match the C version. let so: *lso = amalloc(l.a, 64u64): *lso; - so.path = d_cstr_to_str(l.a, path); - so.soname = d_cstr_to_str(l.a, soname_cs); + so.path = dcstrtostr(l.a, path); + so.soname = dcstrtostr(l.a, soname_cs); so.exports = nil; let tail: *lexport = nil; let si: u64 = 1u64; for (si < nsyms) { let s_p: u64 = dynsym_off + si * SY_SIZE; - let st_shndx: u16 = d_u16(buf, s_p + SY_SHNDX); + let st_shndx: u16 = du16(buf, s_p + SY_SHNDX); if (st_shndx == 0u16) { si += 1u64; } else { let st_info: u8 = buf[s_p + SY_INFO]; let bind: u32 = (st_info: u32) >> 4u32; @@ -1201,7 +1201,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { si += 1u64; continue; }; }; - let st_name: u32 = d_u32(buf, s_p + SY_NAME); + let st_name: u32 = du32(buf, s_p + SY_NAME); let nm_p: *u8 = dynstr + (st_name: u64); if (nm_p[0u64] == 0u8) { si += 1u64; @@ -1213,7 +1213,7 @@ export fn loadso(l: *lnk, path: *u8) i32 = { let vername_cs: *u8 = nil; let keep: i32 = 1; if (has_versym != 0) { - let v: u16 = d_u16(buf, versym_off + si * 2u64); + let v: u16 = du16(buf, versym_off + si * 2u64); if ((v & VERSYM_HIDDEN_C) != 0u16) { keep = 0; // non-default } else { @@ -1239,12 +1239,12 @@ export fn loadso(l: *lnk, path: *u8) i32 = { if (keep != 0) { let e: *lexport = amalloc(l.a, 48u64): *lexport; - e.name = d_cstr_to_str(l.a, nm_p); + e.name = dcstrtostr(l.a, nm_p); if (vername_cs == nil) { e.version.ptr = nil; e.version.len = 0i32; } else { - e.version = d_cstr_to_str(l.a, vername_cs); + e.version = dcstrtostr(l.a, vername_cs); }; e.enext = nil; if (tail == nil) { @@ -1501,50 +1501,50 @@ def PAGE: u64 = 4096u64; // The PT_INTERP literal. Returned via a fn to dodge `def : str = "..."` // breakage in the current cgen. -fn interp_str_v() str = { +fn interpstrv() str = { return "/lib64/ld-linux-x86-64.so.2"; }; // ---- byte writers ------------------------------------------------------ -fn d_wr8(buf: *u8, off: u64, v: u8) void = { +fn dwr8(buf: *u8, off: u64, v: u8) void = { buf[off] = v; }; -fn d_wr16(buf: *u8, off: u64, v: u16) void = { +fn dwr16(buf: *u8, off: u64, v: u16) void = { buf[off] = (v & 255u16): u8; buf[off + 1u64] = ((v >> 8u16) & 255u16): u8; }; -fn d_wr32(buf: *u8, off: u64, v: u32) void = { +fn dwr32(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 d_wr64(buf: *u8, off: u64, v: u64) void = { - d_wr32(buf, off, (v & 4294967295u64): u32); - d_wr32(buf, off + 4u64, ((v >> 32u64) & 4294967295u64): u32); +fn dwr64(buf: *u8, off: u64, v: u64) void = { + dwr32(buf, off, (v & 4294967295u64): u32); + dwr32(buf, off + 4u64, ((v >> 32u64) & 4294967295u64): u32); }; -fn d_wri64(buf: *u8, off: u64, v: i64) void = { - d_wr64(buf, off, v: u64); +fn dwri64(buf: *u8, off: u64, v: i64) void = { + dwr64(buf, off, v: u64); }; -fn d_wri32(buf: *u8, off: u64, v: i32) void = { - d_wr32(buf, off, v: u32); +fn dwri32(buf: *u8, off: u64, v: i32) void = { + dwr32(buf, off, v: u32); }; // ---- byte readers ------------------------------------------------------ -fn d_rd_u16(p: *u8, off: u64) u16 = { +fn drdu16(p: *u8, off: u64) u16 = { let b0: u16 = p[off]: u16; let b1: u16 = p[off + 1u64]: u16; return b0 | (b1 << 8u16); }; -fn d_rd_u32(p: *u8, off: u64) u32 = { +fn drdu32(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; @@ -1552,11 +1552,11 @@ fn d_rd_u32(p: *u8, off: u64) u32 = { return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32); }; -fn d_rd_i32(p: *u8, off: u64) i32 = { - return d_rd_u32(p, off): i32; +fn drdi32(p: *u8, off: u64) i32 = { + return drdu32(p, off): i32; }; -fn d_bcopy(dst: *u8, off: u64, src: *u8, n: u64) void = { +fn dbcopy(dst: *u8, off: u64, src: *u8, n: u64) void = { let i: u64 = 0u64; for (i < n) { dst[off + i] = src[i]; @@ -1564,8 +1564,8 @@ fn d_bcopy(dst: *u8, off: u64, src: *u8, n: u64) void = { }; }; -// elf_hash — SysV ELF hash. Used for .gnu.version_r's vna_hash. -fn elf_hash(name: str) u32 = { +// elfhash — SysV ELF hash. Used for .gnu.version_r's vna_hash. +fn elfhash(name: str) u32 = { let h: u32 = 0u32; let i: i32 = 0; for (i < name.len) { @@ -1579,11 +1579,11 @@ fn elf_hash(name: str) u32 = { return h; }; -fn align_up(off: u64, a: u64) u64 = { +fn alignup(off: u64, a: u64) u64 = { return (off + a - 1u64) & ~(a - 1u64); }; -fn str_eq_d(a: str, b: str) bool = { +fn streqd(a: str, b: str) bool = { if (a.len != b.len) { return false; }; let i: i32 = 0; for (i < a.len) { @@ -1684,8 +1684,8 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { } else { j += 1; }; }; if (has != 0) { - d_wr32(vlib_sos_idx_buf, (n_vlibs: u64) * 4u64, si: u32); - d_wr32(vlib_first_buf, (n_vlibs: u64) * 4u64, n_vers: u32); + dwr32(vlib_sos_idx_buf, (n_vlibs: u64) * 4u64, si: u32); + dwr32(vlib_first_buf, (n_vlibs: u64) * 4u64, n_vers: u32); let added: i32 = 0; let jj: i32 = 0; for (jj < n) { @@ -1701,15 +1701,15 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let kk: i32 = n_vers - added + k; let existing: str; existing.ptr = ver_name_ptr_arr[kk]; - existing.len = d_rd_i32(ver_name_len_buf, (kk: u64) * 4u64); - if (str_eq_d(existing, vname)) { + existing.len = drdi32(ver_name_len_buf, (kk: u64) * 4u64); + if (streqd(existing, vname)) { seen = 1; k = added; } else { k += 1; }; }; if (seen == 0) { - d_wr32(ver_lib_idx_buf, (n_vers: u64) * 4u64, n_vlibs: u32); + dwr32(ver_lib_idx_buf, (n_vers: u64) * 4u64, n_vlibs: u32); ver_name_ptr_arr[n_vers] = vname.ptr; - d_wri32(ver_name_len_buf, (n_vers: u64) * 4u64, vname.len); + dwri32(ver_name_len_buf, (n_vers: u64) * 4u64, vname.len); n_vers += 1; added += 1; }; @@ -1717,7 +1717,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; jj += 1; }; - d_wr32(vlib_count_buf, (n_vlibs: u64) * 4u64, added: u32); + dwr32(vlib_count_buf, (n_vlibs: u64) * 4u64, added: u32); n_vlibs += 1; }; si += 1; @@ -1727,11 +1727,11 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let next_vna: u16 = 2u16; let vi: i32 = 0; for (vi < n_vlibs) { - let first: i32 = d_rd_i32(vlib_first_buf, (vi: u64) * 4u64); - let cnt: i32 = d_rd_i32(vlib_count_buf, (vi: u64) * 4u64); + let first: i32 = drdi32(vlib_first_buf, (vi: u64) * 4u64); + let cnt: i32 = drdi32(vlib_count_buf, (vi: u64) * 4u64); let k: i32 = 0; for (k < cnt) { - d_wr16(ver_vna_other, ((first + k): u64) * 2u64, next_vna); + dwr16(ver_vna_other, ((first + k): u64) * 2u64, next_vna); next_vna += 1u16; k += 1; }; @@ -1756,7 +1756,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; pi = 0; for (pi < n_vers) { - let nm_len: i32 = d_rd_i32(ver_name_len_buf, (pi: u64) * 4u64); + let nm_len: i32 = drdi32(ver_name_len_buf, (pi: u64) * 4u64); dynstr_sz += nm_len: u64; dynstr_sz += 1u64; pi += 1; @@ -1769,10 +1769,10 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let soname_str: *u8 = amalloc(a, (nsos: u64) * 4u64): *u8; pi = 0; for (pi < nsos) { - d_wr32(soname_str, (pi: u64) * 4u64, dynstr_pos: u32); + dwr32(soname_str, (pi: u64) * 4u64, dynstr_pos: u32); let so2: *lso = sos_used[pi]; let snm: str = so2.soname; - d_bcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); + dbcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); dynstr_pos += snm.len: u64; dynstr[dynstr_pos] = 0u8; dynstr_pos += 1u64; @@ -1781,10 +1781,10 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let symname_str: *u8 = amalloc(a, nu * 4u64): *u8; pi = 0; for (pi < n) { - d_wr32(symname_str, (pi: u64) * 4u64, dynstr_pos: u32); + dwr32(symname_str, (pi: u64) * 4u64, dynstr_pos: u32); let dsm: *lsym = dynsyms[pi]; let snm: str = dsm.name; - d_bcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); + dbcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64); dynstr_pos += snm.len: u64; dynstr[dynstr_pos] = 0u8; dynstr_pos += 1u64; @@ -1792,10 +1792,10 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; pi = 0; for (pi < n_vers) { - d_wr32(ver_dynstr_off, (pi: u64) * 4u64, dynstr_pos: u32); + dwr32(ver_dynstr_off, (pi: u64) * 4u64, dynstr_pos: u32); let nm_p: *u8 = ver_name_ptr_arr[pi]; - let nm_len: i32 = d_rd_i32(ver_name_len_buf, (pi: u64) * 4u64); - d_bcopy(dynstr, dynstr_pos, nm_p, nm_len: u64); + let nm_len: i32 = drdi32(ver_name_len_buf, (pi: u64) * 4u64); + dbcopy(dynstr, dynstr_pos, nm_p, nm_len: u64); dynstr_pos += nm_len: u64; dynstr[dynstr_pos] = 0u8; dynstr_pos += 1u64; @@ -1811,27 +1811,27 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let nm3: str = dsm3.name; let vname: str = soversion(dl3, nm3); if (vname.len == 0) { - d_wr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); + dwr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); } else { let matched: i32 = 0; let vk: i32 = 0; for (vk < n_vers) { - let vlx: i32 = d_rd_i32(ver_lib_idx_buf, (vk: u64) * 4u64); - let sosx: i32 = d_rd_i32(vlib_sos_idx_buf, (vlx: u64) * 4u64); + let vlx: i32 = drdi32(ver_lib_idx_buf, (vk: u64) * 4u64); + let sosx: i32 = drdi32(vlib_sos_idx_buf, (vlx: u64) * 4u64); if (sos_used[sosx] == dl3) { let exi: str; exi.ptr = ver_name_ptr_arr[vk]; - exi.len = d_rd_i32(ver_name_len_buf, (vk: u64) * 4u64); - if (str_eq_d(exi, vname)) { - let other: u16 = d_rd_u16(ver_vna_other, (vk: u64) * 2u64); - d_wr16(versym_for, (pi: u64) * 2u64, other); + exi.len = drdi32(ver_name_len_buf, (vk: u64) * 4u64); + if (streqd(exi, vname)) { + let other: u16 = drdu16(ver_vna_other, (vk: u64) * 2u64); + dwr16(versym_for, (pi: u64) * 2u64, other); matched = 1; vk = n_vers; } else { vk += 1; }; } else { vk += 1; }; }; if (matched == 0) { - d_wr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); + dwr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D); }; }; pi += 1; @@ -1841,7 +1841,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let ehdr_sz: u64 = 64u64; let n_phdrs: u64 = 4u64; let phdr_sz: u64 = n_phdrs * 56u64; - let is_local: str = interp_str_v(); + let is_local: str = interpstrv(); let interp_sz: u64 = (is_local.len: u64) + 1u64; let nsyms_total: u64 = 1u64 + nu; @@ -1859,7 +1859,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let verneed_sz: u64 = 0u64; let vli: i32 = 0; for (vli < n_vlibs) { - let cnt: i32 = d_rd_i32(vlib_count_buf, (vli: u64) * 4u64); + let cnt: i32 = drdi32(vlib_count_buf, (vli: u64) * 4u64); verneed_sz += 16u64 + 16u64 * (cnt: u64); vli += 1; }; @@ -1874,23 +1874,23 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { // ---- compute file offsets ---- let off: u64 = ehdr_sz + phdr_sz; let interp_off: u64 = off; off += interp_sz; - off = align_up(off, 8u64); + off = alignup(off, 8u64); let dynstr_off: u64 = off; off += dynstr_sz; - off = align_up(off, 8u64); + off = alignup(off, 8u64); let dynsym_off: u64 = off; off += dynsym_sz; let hash_off: u64 = off; off += hash_sz; - off = align_up(off, 2u64); + off = alignup(off, 2u64); let versym_off: u64 = off; off += versym_sz; - off = align_up(off, 4u64); + off = alignup(off, 4u64); let verneed_off: u64 = off; off += verneed_sz; - off = align_up(off, 8u64); + off = alignup(off, 8u64); let relaplt_off: u64 = off; off += relaplt_sz; - let text_off: u64 = align_up(off, PAGE); + let text_off: u64 = alignup(off, PAGE); let plt_off: u64 = text_off + l.textlen; let rx_end: u64 = plt_off + plt_sz; - let gotplt_off: u64 = align_up(rx_end, PAGE); + let gotplt_off: u64 = alignup(rx_end, PAGE); let dynamic_off: u64 = gotplt_off + gotplt_sz; let file_end: u64 = dynamic_off + dynamic_sz; @@ -1911,27 +1911,27 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { pi = 0; for (pi < n) { let eoff: u64 = (1u64 + (pi: u64)) * 24u64; - d_wr32(dynsym_buf, eoff + 0u64, d_rd_u32(symname_str, (pi: u64) * 4u64)); - d_wr8(dynsym_buf, eoff + 4u64, (STB_GLOBAL_D << 4u8) | (STT_FUNC_D & 15u8)); - d_wr8(dynsym_buf, eoff + 5u64, 0u8); - d_wr16(dynsym_buf, eoff + 6u64, 0u16); - d_wr64(dynsym_buf, eoff + 8u64, 0u64); - d_wr64(dynsym_buf, eoff + 16u64, 0u64); + dwr32(dynsym_buf, eoff + 0u64, drdu32(symname_str, (pi: u64) * 4u64)); + dwr8(dynsym_buf, eoff + 4u64, (STB_GLOBAL_D << 4u8) | (STT_FUNC_D & 15u8)); + dwr8(dynsym_buf, eoff + 5u64, 0u8); + dwr16(dynsym_buf, eoff + 6u64, 0u16); + dwr64(dynsym_buf, eoff + 8u64, 0u64); + dwr64(dynsym_buf, eoff + 16u64, 0u64); pi += 1; }; // ---- build .hash (SysV, 1 bucket) ---- let hash_buf: *u8 = amalloc(a, hash_sz): *u8; - d_wr32(hash_buf, 0u64, nbuckets); - d_wr32(hash_buf, 4u64, nchain); + dwr32(hash_buf, 0u64, nbuckets); + dwr32(hash_buf, 4u64, nchain); let bucket0: u32 = 0u32; if (nsyms_total > 1u64) { bucket0 = 1u32; }; - d_wr32(hash_buf, 8u64, bucket0); + dwr32(hash_buf, 8u64, bucket0); let ci: u64 = 1u64; for (ci < nsyms_total) { let nxt: u32 = 0u32; if (ci + 1u64 < nsyms_total) { nxt = (ci + 1u64): u32; }; - d_wr32(hash_buf, 8u64 + (nbuckets: u64) * 4u64 + ci * 4u64, nxt); + dwr32(hash_buf, 8u64 + (nbuckets: u64) * 4u64 + ci * 4u64, nxt); ci += 1u64; }; @@ -1940,19 +1940,19 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { pi = 0; for (pi < n) { let roff: u64 = (pi: u64) * 24u64; - d_wr64(relaplt_buf, roff + 0u64, gotplt_va + (3u64 + (pi: u64)) * 8u64); + dwr64(relaplt_buf, roff + 0u64, gotplt_va + (3u64 + (pi: u64)) * 8u64); let info: u64 = ((1u64 + (pi: u64)) << 32u64) | (R_X86_64_JUMP_SLOT_D: u64); - d_wr64(relaplt_buf, roff + 8u64, info); - d_wri64(relaplt_buf, roff + 16u64, 0i64); + dwr64(relaplt_buf, roff + 8u64, info); + dwri64(relaplt_buf, roff + 16u64, 0i64); pi += 1; }; // ---- build .gnu.version (u16 per dynsym entry) ---- let versym_buf: *u8 = amalloc(a, versym_sz): *u8; - d_wr16(versym_buf, 0u64, VER_NDX_LOCAL_D); + dwr16(versym_buf, 0u64, VER_NDX_LOCAL_D); pi = 0; for (pi < n) { - d_wr16(versym_buf, 2u64 + (pi: u64) * 2u64, d_rd_u16(versym_for, (pi: u64) * 2u64)); + dwr16(versym_buf, 2u64 + (pi: u64) * 2u64, drdu16(versym_for, (pi: u64) * 2u64)); pi += 1; }; @@ -1962,35 +1962,35 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let vnoff: u64 = 0u64; vli = 0; for (vli < n_vlibs) { - let sos_idx: i32 = d_rd_i32(vlib_sos_idx_buf, (vli: u64) * 4u64); - let first: i32 = d_rd_i32(vlib_first_buf, (vli: u64) * 4u64); - let cnt: i32 = d_rd_i32(vlib_count_buf, (vli: u64) * 4u64); + let sos_idx: i32 = drdi32(vlib_sos_idx_buf, (vli: u64) * 4u64); + let first: i32 = drdi32(vlib_first_buf, (vli: u64) * 4u64); + let cnt: i32 = drdi32(vlib_count_buf, (vli: u64) * 4u64); let vn_start: u64 = vnoff; - d_wr16(verneed_buf, vnoff + 0u64, 1u16); - d_wr16(verneed_buf, vnoff + 2u64, cnt: u16); - d_wr32(verneed_buf, vnoff + 4u64, d_rd_u32(soname_str, (sos_idx: u64) * 4u64)); - d_wr32(verneed_buf, vnoff + 8u64, 16u32); + dwr16(verneed_buf, vnoff + 0u64, 1u16); + dwr16(verneed_buf, vnoff + 2u64, cnt: u16); + dwr32(verneed_buf, vnoff + 4u64, drdu32(soname_str, (sos_idx: u64) * 4u64)); + dwr32(verneed_buf, vnoff + 8u64, 16u32); vnoff += 16u64; let k: i32 = 0; for (k < cnt) { let vk: i32 = first + k; let nm: str; nm.ptr = ver_name_ptr_arr[vk]; - nm.len = d_rd_i32(ver_name_len_buf, (vk: u64) * 4u64); - let h: u32 = elf_hash(nm); - d_wr32(verneed_buf, vnoff + 0u64, h); - d_wr16(verneed_buf, vnoff + 4u64, 0u16); - d_wr16(verneed_buf, vnoff + 6u64, d_rd_u16(ver_vna_other, (vk: u64) * 2u64)); - d_wr32(verneed_buf, vnoff + 8u64, d_rd_u32(ver_dynstr_off, (vk: u64) * 4u64)); + nm.len = drdi32(ver_name_len_buf, (vk: u64) * 4u64); + let h: u32 = elfhash(nm); + dwr32(verneed_buf, vnoff + 0u64, h); + dwr16(verneed_buf, vnoff + 4u64, 0u16); + dwr16(verneed_buf, vnoff + 6u64, drdu16(ver_vna_other, (vk: u64) * 2u64)); + dwr32(verneed_buf, vnoff + 8u64, drdu32(ver_dynstr_off, (vk: u64) * 4u64)); let nxt: u32 = 0u32; if (k + 1 < cnt) { nxt = 16u32; }; - d_wr32(verneed_buf, vnoff + 12u64, nxt); + dwr32(verneed_buf, vnoff + 12u64, nxt); vnoff += 16u64; k += 1; }; let vn_nxt: u32 = 0u32; if (vli + 1 < n_vlibs) { vn_nxt = (vnoff - vn_start): u32; }; - d_wr32(verneed_buf, vn_start + 12u64, vn_nxt); + dwr32(verneed_buf, vn_start + 12u64, vn_nxt); vli += 1; }; }; @@ -2004,42 +2004,42 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let next_ip: u64 = stub_va + 6u64; let slot_va: u64 = gotplt_va + (3u64 + (pi: u64)) * 8u64; let disp: i64 = (slot_va: i64) - (next_ip: i64); - d_wr8(plt_buf, p_off + 0u64, 255u8); - d_wr8(plt_buf, p_off + 1u64, 37u8); - d_wr32(plt_buf, p_off + 2u64, (disp: i32): u32); + dwr8(plt_buf, p_off + 0u64, 255u8); + dwr8(plt_buf, p_off + 1u64, 37u8); + dwr32(plt_buf, p_off + 2u64, (disp: i32): u32); pi += 1; }; // ---- build .got.plt ---- let gotplt_buf: *u8 = amalloc(a, gotplt_sz): *u8; - d_wr64(gotplt_buf, 0u64, dynamic_va); + dwr64(gotplt_buf, 0u64, dynamic_va); // ---- build .dynamic ---- let dynamic_buf: *u8 = amalloc(a, dynamic_sz): *u8; let dk: u64 = 0u64; pi = 0; for (pi < nsos) { - d_wri64(dynamic_buf, dk * 16u64 + 0u64, DT_NEEDED); - d_wr64(dynamic_buf, dk * 16u64 + 8u64, d_rd_u32(soname_str, (pi: u64) * 4u64): u64); + dwri64(dynamic_buf, dk * 16u64 + 0u64, DT_NEEDED); + dwr64(dynamic_buf, dk * 16u64 + 8u64, drdu32(soname_str, (pi: u64) * 4u64): u64); dk += 1u64; pi += 1; }; - d_wri64(dynamic_buf, dk * 16u64, DT_HASH); d_wr64(dynamic_buf, dk * 16u64 + 8u64, hash_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_STRTAB); d_wr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_SYMTAB); d_wr64(dynamic_buf, dk * 16u64 + 8u64, dynsym_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_STRSZ); d_wr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_sz); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_SYMENT); d_wr64(dynamic_buf, dk * 16u64 + 8u64, 24u64); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_PLTGOT); d_wr64(dynamic_buf, dk * 16u64 + 8u64, gotplt_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_PLTRELSZ); d_wr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_sz); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_PLTREL); d_wr64(dynamic_buf, dk * 16u64 + 8u64, DT_RELA: u64);dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_JMPREL); d_wr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_BIND_NOW); d_wr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_HASH); dwr64(dynamic_buf, dk * 16u64 + 8u64, hash_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_STRTAB); dwr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_SYMTAB); dwr64(dynamic_buf, dk * 16u64 + 8u64, dynsym_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_STRSZ); dwr64(dynamic_buf, dk * 16u64 + 8u64, dynstr_sz); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_SYMENT); dwr64(dynamic_buf, dk * 16u64 + 8u64, 24u64); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_PLTGOT); dwr64(dynamic_buf, dk * 16u64 + 8u64, gotplt_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_PLTRELSZ); dwr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_sz); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_PLTREL); dwr64(dynamic_buf, dk * 16u64 + 8u64, DT_RELA: u64);dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_JMPREL); dwr64(dynamic_buf, dk * 16u64 + 8u64, relaplt_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_BIND_NOW); dwr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; if (with_ver != 0) { - d_wri64(dynamic_buf, dk * 16u64, DT_VERSYM); d_wr64(dynamic_buf, dk * 16u64 + 8u64, versym_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_VERNEED); d_wr64(dynamic_buf, dk * 16u64 + 8u64, verneed_va); dk += 1u64; - d_wri64(dynamic_buf, dk * 16u64, DT_VERNEEDNUM); d_wr64(dynamic_buf, dk * 16u64 + 8u64, n_vlibs: u64);dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_VERSYM); dwr64(dynamic_buf, dk * 16u64 + 8u64, versym_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_VERNEED); dwr64(dynamic_buf, dk * 16u64 + 8u64, verneed_va); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_VERNEEDNUM); dwr64(dynamic_buf, dk * 16u64 + 8u64, n_vlibs: u64);dk += 1u64; }; - d_wri64(dynamic_buf, dk * 16u64, DT_NULL); d_wr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; + dwri64(dynamic_buf, dk * 16u64, DT_NULL); dwr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64; if (dk != ndyn) { os.write(2, "w6l: dynamic entry count mismatch\n".ptr, 33u64); return 1; @@ -2060,7 +2060,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { let site: u64 = text_va + r.off; let stub: u64 = plt_va + (rsym.pltidx: u64) * PLT_STUB_BYTES_D; let disp: i64 = (stub: i64) - (site: i64) + r.addend; - d_wr32(l.text, r.off, (disp: i32): u32); + dwr32(l.text, r.off, (disp: i32): u32); }; }; r = r.rnext; @@ -2074,86 +2074,86 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = { }; // Ehdr - d_wr8(file_buf, 0u64, 127u8); - d_wr8(file_buf, 1u64, 69u8); - d_wr8(file_buf, 2u64, 76u8); - d_wr8(file_buf, 3u64, 70u8); - d_wr8(file_buf, 4u64, ELFCLASS64_D); - d_wr8(file_buf, 5u64, ELFDATA2LSB_D); - d_wr8(file_buf, 6u64, EV_CURRENT_D: u8); - d_wr16(file_buf, 16u64, ET_EXEC_D); - d_wr16(file_buf, 18u64, EM_X86_64_D); - d_wr32(file_buf, 20u64, EV_CURRENT_D); - d_wr64(file_buf, 24u64, entry); - d_wr64(file_buf, 32u64, ehdr_sz); - d_wr64(file_buf, 40u64, 0u64); - d_wr32(file_buf, 48u64, 0u32); - d_wr16(file_buf, 52u64, ehdr_sz: u16); - d_wr16(file_buf, 54u64, 56u16); - d_wr16(file_buf, 56u64, n_phdrs: u16); - d_wr16(file_buf, 58u64, 0u16); - d_wr16(file_buf, 60u64, 0u16); - d_wr16(file_buf, 62u64, 0u16); + dwr8(file_buf, 0u64, 127u8); + dwr8(file_buf, 1u64, 69u8); + dwr8(file_buf, 2u64, 76u8); + dwr8(file_buf, 3u64, 70u8); + dwr8(file_buf, 4u64, ELFCLASS64_D); + dwr8(file_buf, 5u64, ELFDATA2LSB_D); + dwr8(file_buf, 6u64, EV_CURRENT_D: u8); + dwr16(file_buf, 16u64, ET_EXEC_D); + dwr16(file_buf, 18u64, EM_X86_64_D); + dwr32(file_buf, 20u64, EV_CURRENT_D); + dwr64(file_buf, 24u64, entry); + dwr64(file_buf, 32u64, ehdr_sz); + dwr64(file_buf, 40u64, 0u64); + dwr32(file_buf, 48u64, 0u32); + dwr16(file_buf, 52u64, ehdr_sz: u16); + dwr16(file_buf, 54u64, 56u16); + dwr16(file_buf, 56u64, n_phdrs: u16); + dwr16(file_buf, 58u64, 0u16); + dwr16(file_buf, 60u64, 0u16); + dwr16(file_buf, 62u64, 0u16); // Phdrs at offset 64. let p0: u64 = 64u64; - d_wr32(file_buf, p0 + 0u64, PT_LOAD_D); - d_wr32(file_buf, p0 + 4u64, PF_R_D | PF_X_D); - d_wr64(file_buf, p0 + 8u64, 0u64); - d_wr64(file_buf, p0 + 16u64, base); - d_wr64(file_buf, p0 + 24u64, base); - d_wr64(file_buf, p0 + 32u64, rx_end); - d_wr64(file_buf, p0 + 40u64, rx_end); - d_wr64(file_buf, p0 + 48u64, PAGE); + dwr32(file_buf, p0 + 0u64, PT_LOAD_D); + dwr32(file_buf, p0 + 4u64, PF_R_D | PF_X_D); + dwr64(file_buf, p0 + 8u64, 0u64); + dwr64(file_buf, p0 + 16u64, base); + dwr64(file_buf, p0 + 24u64, base); + dwr64(file_buf, p0 + 32u64, rx_end); + dwr64(file_buf, p0 + 40u64, rx_end); + dwr64(file_buf, p0 + 48u64, PAGE); let p1: u64 = 64u64 + 56u64; - d_wr32(file_buf, p1 + 0u64, PT_LOAD_D); - d_wr32(file_buf, p1 + 4u64, PF_R_D | PF_W_D); - d_wr64(file_buf, p1 + 8u64, gotplt_off); - d_wr64(file_buf, p1 + 16u64, gotplt_va); - d_wr64(file_buf, p1 + 24u64, gotplt_va); - d_wr64(file_buf, p1 + 32u64, file_end - gotplt_off); - d_wr64(file_buf, p1 + 40u64, file_end - gotplt_off); - d_wr64(file_buf, p1 + 48u64, PAGE); + dwr32(file_buf, p1 + 0u64, PT_LOAD_D); + dwr32(file_buf, p1 + 4u64, PF_R_D | PF_W_D); + dwr64(file_buf, p1 + 8u64, gotplt_off); + dwr64(file_buf, p1 + 16u64, gotplt_va); + dwr64(file_buf, p1 + 24u64, gotplt_va); + dwr64(file_buf, p1 + 32u64, file_end - gotplt_off); + dwr64(file_buf, p1 + 40u64, file_end - gotplt_off); + dwr64(file_buf, p1 + 48u64, PAGE); let p2: u64 = 64u64 + 112u64; - d_wr32(file_buf, p2 + 0u64, PT_INTERP_D); - d_wr32(file_buf, p2 + 4u64, PF_R_D); - d_wr64(file_buf, p2 + 8u64, interp_off); - d_wr64(file_buf, p2 + 16u64, interp_va); - d_wr64(file_buf, p2 + 24u64, interp_va); - d_wr64(file_buf, p2 + 32u64, interp_sz); - d_wr64(file_buf, p2 + 40u64, interp_sz); - d_wr64(file_buf, p2 + 48u64, 1u64); + dwr32(file_buf, p2 + 0u64, PT_INTERP_D); + dwr32(file_buf, p2 + 4u64, PF_R_D); + dwr64(file_buf, p2 + 8u64, interp_off); + dwr64(file_buf, p2 + 16u64, interp_va); + dwr64(file_buf, p2 + 24u64, interp_va); + dwr64(file_buf, p2 + 32u64, interp_sz); + dwr64(file_buf, p2 + 40u64, interp_sz); + dwr64(file_buf, p2 + 48u64, 1u64); let p3: u64 = 64u64 + 168u64; - d_wr32(file_buf, p3 + 0u64, PT_DYNAMIC_D); - d_wr32(file_buf, p3 + 4u64, PF_R_D | PF_W_D); - d_wr64(file_buf, p3 + 8u64, dynamic_off); - d_wr64(file_buf, p3 + 16u64, dynamic_va); - d_wr64(file_buf, p3 + 24u64, dynamic_va); - d_wr64(file_buf, p3 + 32u64, dynamic_sz); - d_wr64(file_buf, p3 + 40u64, dynamic_sz); - d_wr64(file_buf, p3 + 48u64, 8u64); + dwr32(file_buf, p3 + 0u64, PT_DYNAMIC_D); + dwr32(file_buf, p3 + 4u64, PF_R_D | PF_W_D); + dwr64(file_buf, p3 + 8u64, dynamic_off); + dwr64(file_buf, p3 + 16u64, dynamic_va); + dwr64(file_buf, p3 + 24u64, dynamic_va); + dwr64(file_buf, p3 + 32u64, dynamic_sz); + dwr64(file_buf, p3 + 40u64, dynamic_sz); + dwr64(file_buf, p3 + 48u64, 8u64); // Sections. - let interp_local: str = interp_str_v(); - d_bcopy(file_buf, interp_off, interp_local.ptr, interp_local.len: u64); - d_wr8(file_buf, interp_off + (interp_local.len: u64), 0u8); - d_bcopy(file_buf, dynstr_off, dynstr, dynstr_sz); - d_bcopy(file_buf, dynsym_off, dynsym_buf, dynsym_sz); - d_bcopy(file_buf, hash_off, hash_buf, hash_sz); - d_bcopy(file_buf, versym_off, versym_buf, versym_sz); + let interp_local: str = interpstrv(); + dbcopy(file_buf, interp_off, interp_local.ptr, interp_local.len: u64); + dwr8(file_buf, interp_off + (interp_local.len: u64), 0u8); + dbcopy(file_buf, dynstr_off, dynstr, dynstr_sz); + dbcopy(file_buf, dynsym_off, dynsym_buf, dynsym_sz); + dbcopy(file_buf, hash_off, hash_buf, hash_sz); + dbcopy(file_buf, versym_off, versym_buf, versym_sz); if (verneed_sz > 0u64) { - d_bcopy(file_buf, verneed_off, verneed_buf, verneed_sz); + dbcopy(file_buf, verneed_off, verneed_buf, verneed_sz); }; - d_bcopy(file_buf, relaplt_off, relaplt_buf, relaplt_sz); + dbcopy(file_buf, relaplt_off, relaplt_buf, relaplt_sz); if (l.textlen > 0u64) { - d_bcopy(file_buf, text_off, l.text, l.textlen); + dbcopy(file_buf, text_off, l.text, l.textlen); }; - d_bcopy(file_buf, plt_off, plt_buf, plt_sz); - d_bcopy(file_buf, gotplt_off, gotplt_buf, gotplt_sz); - d_bcopy(file_buf, dynamic_off, dynamic_buf, dynamic_sz); + dbcopy(file_buf, plt_off, plt_buf, plt_sz); + dbcopy(file_buf, gotplt_off, gotplt_buf, gotplt_sz); + dbcopy(file_buf, dynamic_off, dynamic_buf, dynamic_sz); let wrote: i64 = os.writefull(fd, file_buf, file_end); if (wrote != file_end: i64) { diff --git a/selfhost/cmd/w6l/obj.ww b/selfhost/cmd/w6l/obj.ww index b65bd43c..c4abc1c1 100644 --- a/selfhost/cmd/w6l/obj.ww +++ b/selfhost/cmd/w6l/obj.ww @@ -23,13 +23,13 @@ def SHT_RELA: i32 = 4; // 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 rd_u16(p: *u8, off: u64) u16 = { +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 rd_u32(p: *u8, off: u64) u32 = { +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; @@ -37,9 +37,9 @@ fn rd_u32(p: *u8, off: u64) u32 = { return b0 | (b1 << 8u32) | (b2 << 16u32) | (b3 << 24u32); }; -fn rd_u64(p: *u8, off: u64) u64 = { - let lo: u64 = rd_u32(p, off): u64; - let hi: u64 = rd_u32(p, off + 4u64): u64; +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); }; @@ -196,11 +196,11 @@ fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = { if (buf[2u64] != 76u8) { return nil; }; if (buf[3u64] != 70u8) { return nil; }; - let shoff: u64 = rd_u64(buf, EHDR_SHOFF); - let shnum: u32 = rd_u16(buf, EHDR_SHNUM): u32; - let shstrndx: u32 = rd_u16(buf, EHDR_SHSTRNDX): u32; + 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 = rd_u64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET); + 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; @@ -208,8 +208,8 @@ fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = { let i: u32 = 0u32; for (i < shnum) { let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE; - let sh_type: u32 = rd_u32(buf, sh_off + SHDR_TYPE); - let sh_name: u32 = rd_u32(buf, sh_off + SHDR_NAME); + 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; }; @@ -221,22 +221,22 @@ fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = { if (idx_symtab < 0) { return nil; }; let sym_sh: u64 = shoff + (idx_symtab: u64) * SHDR_SIZE; - let sym_off: u64 = rd_u64(buf, sym_sh + SHDR_OFFSET); - let sym_size: u64 = rd_u64(buf, sym_sh + SHDR_SIZE_F); - let sym_link: u32 = rd_u32(buf, sym_sh + SHDR_LINK); + 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 = rd_u64(buf, str_sh + SHDR_OFFSET); + 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 = rd_u32(buf, sym_p + SYM_NAME); + let st_name: u32 = rdu32(buf, sym_p + SYM_NAME); let st_info: u8 = buf[sym_p + SYM_INFO]; - let st_shndx: u16 = rd_u16(buf, sym_p + SYM_SHNDX); + 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) { @@ -353,14 +353,14 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { if (buf[2u64] != 76u8) { return -1; }; if (buf[3u64] != 70u8) { return -1; }; if (buf[4u64] != 2u8) { return -1; }; // ELFCLASS64 - if (rd_u16(buf, EHDR_TYPE) != ET_REL: u16) { return -1; }; - if (rd_u16(buf, EHDR_MACHINE) != EM_X86_64: u16) { return -1; }; + if (rdu16(buf, EHDR_TYPE) != ET_REL: u16) { return -1; }; + if (rdu16(buf, EHDR_MACHINE) != EM_X86_64: u16) { return -1; }; - let shoff: u64 = rd_u64(buf, EHDR_SHOFF); - let shnum: u32 = rd_u16(buf, EHDR_SHNUM): u32; - let shstrndx: u32 = rd_u16(buf, EHDR_SHSTRNDX): u32; + 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 = rd_u64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET); + 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 @@ -370,8 +370,8 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { let i: u32 = 0u32; for (i < shnum) { let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE; - let sh_type: u32 = rd_u32(buf, sh_off + SHDR_TYPE); - let sh_name: u32 = rd_u32(buf, sh_off + SHDR_NAME); + 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; }; @@ -392,17 +392,17 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { }; let text_sh: u64 = shoff + (idx_text: u64) * SHDR_SIZE; - let text_off: u64 = rd_u64(buf, text_sh + SHDR_OFFSET); - let text_size: u64 = rd_u64(buf, text_sh + SHDR_SIZE_F); + 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 = rd_u64(buf, sym_sh + SHDR_OFFSET); - let sym_size: u64 = rd_u64(buf, sym_sh + SHDR_SIZE_F); - let sym_link: u32 = rd_u32(buf, sym_sh + SHDR_LINK); + 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 = rd_u64(buf, str_sh + SHDR_OFFSET); + let str_off: u64 = rdu64(buf, str_sh + SHDR_OFFSET); let strtab: *u8 = buf + str_off; // Track this object. @@ -424,9 +424,9 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { 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 = rd_u32(buf, sym_p + SYM_NAME); - let st_shndx: u16 = rd_u16(buf, sym_p + SYM_SHNDX); - let st_value: u64 = rd_u64(buf, sym_p + SYM_VALUE); + 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); @@ -451,15 +451,15 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { // Per-object relocation collection. if (idx_rela >= 0) { let rela_sh: u64 = shoff + (idx_rela: u64) * SHDR_SIZE; - let rela_off: u64 = rd_u64(buf, rela_sh + SHDR_OFFSET); - let rela_size: u64 = rd_u64(buf, rela_sh + SHDR_SIZE_F); + 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 = rd_u64(buf, rp + RELA_OFFSET); - let r_info: u64 = rd_u64(buf, rp + RELA_INFO); - let r_addend: u64 = rd_u64(buf, rp + RELA_ADDEND); + 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; @@ -469,7 +469,7 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = { // 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 = rd_u32(buf, s_p + SYM_NAME); + 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);