Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

selfhost/cmd/w6l: drop d_/rd_/wr_ prefixes on dyn/dynout/obj helpers

Browse Source
This commit is contained in:
Hojun-Cho
2026-05-11 14:40:05 +09:00
parent fc09320eb7
commit 5d91ee778e
4 changed files with 510 additions and 510 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
selfhost/cmd/w6l/dyn.ww
View File

@@ -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) {

342
selfhost/cmd/w6l/dynout.ww
View File

@@ -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) {

510
selfhost/cmd/w6l/main.combined.ww
View File

File diff suppressed because it is too large Load Diff

80
selfhost/cmd/w6l/obj.ww
View File

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