selfhost: drop snake_case locals in dyn/dynout/obj + w6a + cgen + ww driver
This commit is contained in:
@@ -141,21 +141,21 @@ fn readallso(path: *u8) (*u8, u64) = {
|
||||
// the .so's verstr buffer) for the entry whose vd_ndx == ndx. The name
|
||||
// is the first Verdaux's vda_name (subsequent auxes are predecessor
|
||||
// names). Returns nil if no entry matches.
|
||||
fn vdnameat(buf: *u8, verdef_off: u64, verdef_size: u64,
|
||||
fn vdnameat(buf: *u8, verdefoff: u64, verdefsize: u64,
|
||||
verstr: *u8, ndx: u16) *u8 = {
|
||||
let off: u64 = 0u64;
|
||||
for (off < verdef_size) {
|
||||
let vd_p: u64 = verdef_off + off;
|
||||
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 = du32(buf, aux_p + VA_NAME);
|
||||
return verstr + (vda_name: u64);
|
||||
for (off < verdefsize) {
|
||||
let vdp: u64 = verdefoff + off;
|
||||
let vdndx: u16 = du16(buf, vdp + VD_NDX);
|
||||
let vdaux: u32 = du32(buf, vdp + VD_AUX);
|
||||
let vdnext: u32 = du32(buf, vdp + VD_NEXT);
|
||||
if (vdndx == ndx) {
|
||||
let auxp: u64 = vdp + (vdaux: u64);
|
||||
let vdaname: u32 = du32(buf, auxp + VA_NAME);
|
||||
return verstr + (vdaname: u64);
|
||||
};
|
||||
if (vd_next == 0u32) { return nil; };
|
||||
off += vd_next: u64;
|
||||
if (vdnext == 0u32) { return nil; };
|
||||
off += vdnext: u64;
|
||||
};
|
||||
return nil;
|
||||
};
|
||||
@@ -192,56 +192,56 @@ export fn loadso(l: *lnk, path: *u8) i32 = {
|
||||
if (shnum == 0u32) { return soerr("stripped .so unsupported"); };
|
||||
|
||||
// Locate the four sections we care about.
|
||||
let idx_dynsym: i32 = -1;
|
||||
let idx_dynamic: i32 = -1;
|
||||
let idx_versym: i32 = -1;
|
||||
let idx_verdef: i32 = -1;
|
||||
let idxdynsym: i32 = -1;
|
||||
let idxdynamic: i32 = -1;
|
||||
let idxversym: i32 = -1;
|
||||
let idxverdef: i32 = -1;
|
||||
let i: u32 = 0u32;
|
||||
for (i < shnum) {
|
||||
let sh_p: u64 = shoff + (i: u64) * SH_SIZE;
|
||||
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; };
|
||||
if (sh_type == SHT_GNU_VERDEF) { idx_verdef = i: i32; };
|
||||
let shp: u64 = shoff + (i: u64) * SH_SIZE;
|
||||
let shtype: u32 = du32(buf, shp + SH_TYPE);
|
||||
if (shtype == SHT_DYNSYM) { idxdynsym = i: i32; };
|
||||
if (shtype == SHT_DYNAMIC) { idxdynamic = i: i32; };
|
||||
if (shtype == SHT_GNU_VERSYM) { idxversym = i: i32; };
|
||||
if (shtype == SHT_GNU_VERDEF) { idxverdef = i: i32; };
|
||||
i += 1u32;
|
||||
};
|
||||
if (idx_dynsym < 0) {
|
||||
if (idxdynsym < 0) {
|
||||
return soerr("no .dynsym");
|
||||
};
|
||||
|
||||
let dynsym_sh: u64 = shoff + (idx_dynsym: u64) * SH_SIZE;
|
||||
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 dynsymsh: u64 = shoff + (idxdynsym: u64) * SH_SIZE;
|
||||
let dynsymoff: u64 = du64(buf, dynsymsh + SH_OFFSET);
|
||||
let dynsymsize: u64 = du64(buf, dynsymsh + SH_SIZE_F);
|
||||
let dynsymlink: u32 = du32(buf, dynsymsh + SH_LINK);
|
||||
let nsyms: u64 = dynsymsize / SY_SIZE;
|
||||
|
||||
let dynstr_sh: u64 = shoff + (dynsym_link: u64) * SH_SIZE;
|
||||
let dynstr_off: u64 = du64(buf, dynstr_sh + SH_OFFSET);
|
||||
let dynstr: *u8 = buf + dynstr_off;
|
||||
let dynstrsh: u64 = shoff + (dynsymlink: u64) * SH_SIZE;
|
||||
let dynstroff: u64 = du64(buf, dynstrsh + SH_OFFSET);
|
||||
let dynstr: *u8 = buf + dynstroff;
|
||||
|
||||
// SONAME: .dynamic strings live in the section pointed at by its
|
||||
// sh_link (almost always .dynstr).
|
||||
let soname_cs: *u8 = nil;
|
||||
if (idx_dynamic >= 0) {
|
||||
let dyn_sh: u64 = shoff + (idx_dynamic: u64) * SH_SIZE;
|
||||
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 = du64(buf, dstr_sh + SH_OFFSET);
|
||||
let dstr: *u8 = buf + dstr_off;
|
||||
let nd: u64 = dyn_size / DY_SIZE;
|
||||
let sonamecs: *u8 = nil;
|
||||
if (idxdynamic >= 0) {
|
||||
let dynsh: u64 = shoff + (idxdynamic: u64) * SH_SIZE;
|
||||
let dynoff: u64 = du64(buf, dynsh + SH_OFFSET);
|
||||
let dynsize: u64 = du64(buf, dynsh + SH_SIZE_F);
|
||||
let dynlink: u32 = du32(buf, dynsh + SH_LINK);
|
||||
let dstrsh: u64 = shoff + (dynlink: u64) * SH_SIZE;
|
||||
let dstroff: u64 = du64(buf, dstrsh + SH_OFFSET);
|
||||
let dstr: *u8 = buf + dstroff;
|
||||
let nd: u64 = dynsize / DY_SIZE;
|
||||
let di: u64 = 0u64;
|
||||
for (di < nd) {
|
||||
let d_p: u64 = dyn_off + di * DY_SIZE;
|
||||
let d_tag: i64 = di64(buf, d_p + DY_TAG);
|
||||
if (d_tag == DT_NULL_TAG) {
|
||||
let dp: u64 = dynoff + di * DY_SIZE;
|
||||
let dtag: i64 = di64(buf, dp + DY_TAG);
|
||||
if (dtag == DT_NULL_TAG) {
|
||||
di = nd; // break
|
||||
} else {
|
||||
if (d_tag == DT_SONAME_TAG) {
|
||||
let d_val: u64 = du64(buf, d_p + DY_VAL);
|
||||
soname_cs = dstr + d_val;
|
||||
if (dtag == DT_SONAME_TAG) {
|
||||
let dval: u64 = du64(buf, dp + DY_VAL);
|
||||
sonamecs = dstr + dval;
|
||||
di = nd; // break
|
||||
} else {
|
||||
di += 1u64;
|
||||
@@ -249,66 +249,66 @@ export fn loadso(l: *lnk, path: *u8) i32 = {
|
||||
};
|
||||
};
|
||||
};
|
||||
if (soname_cs == nil) {
|
||||
soname_cs = dbasename(path);
|
||||
if (sonamecs == nil) {
|
||||
sonamecs = dbasename(path);
|
||||
};
|
||||
|
||||
// Versym is one u16 per dynsym entry.
|
||||
let versym_off: u64 = 0u64;
|
||||
let has_versym: i32 = 0;
|
||||
if (idx_versym >= 0) {
|
||||
let vs_sh: u64 = shoff + (idx_versym: u64) * SH_SIZE;
|
||||
versym_off = du64(buf, vs_sh + SH_OFFSET);
|
||||
has_versym = 1;
|
||||
let versymoff: u64 = 0u64;
|
||||
let hasversym: i32 = 0;
|
||||
if (idxversym >= 0) {
|
||||
let vssh: u64 = shoff + (idxversym: u64) * SH_SIZE;
|
||||
versymoff = du64(buf, vssh + SH_OFFSET);
|
||||
hasversym = 1;
|
||||
};
|
||||
|
||||
// Verdef section bounds + the .dynstr-like string section it uses.
|
||||
let verdef_off: u64 = 0u64;
|
||||
let verdef_size: u64 = 0u64;
|
||||
let verdefoff: u64 = 0u64;
|
||||
let verdefsize: u64 = 0u64;
|
||||
let verstr: *u8 = nil;
|
||||
if (idx_verdef >= 0) {
|
||||
let vd_sh: u64 = shoff + (idx_verdef: u64) * SH_SIZE;
|
||||
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 = du64(buf, vstr_sh + SH_OFFSET);
|
||||
verstr = buf + vstr_off;
|
||||
if (idxverdef >= 0) {
|
||||
let vdsh: u64 = shoff + (idxverdef: u64) * SH_SIZE;
|
||||
verdefoff = du64(buf, vdsh + SH_OFFSET);
|
||||
verdefsize = du64(buf, vdsh + SH_SIZE_F);
|
||||
let vdlink: u32 = du32(buf, vdsh + SH_LINK);
|
||||
let vstrsh: u64 = shoff + (vdlink: u64) * SH_SIZE;
|
||||
let vstroff: u64 = du64(buf, vstrsh + SH_OFFSET);
|
||||
verstr = buf + vstroff;
|
||||
};
|
||||
|
||||
// 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 = dcstrtostr(l.a, path);
|
||||
so.soname = dcstrtostr(l.a, soname_cs);
|
||||
so.soname = dcstrtostr(l.a, sonamecs);
|
||||
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 = 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;
|
||||
let sp: u64 = dynsymoff + si * SY_SIZE;
|
||||
let stshndx: u16 = du16(buf, sp + SY_SHNDX);
|
||||
if (stshndx == 0u16) { si += 1u64; } else {
|
||||
let stinfo: u8 = buf[sp + SY_INFO];
|
||||
let bind: u32 = (stinfo: u32) >> 4u32;
|
||||
if (bind != 1u32) { if (bind != 2u32) {
|
||||
// not GLOBAL/WEAK
|
||||
si += 1u64;
|
||||
continue;
|
||||
}; };
|
||||
let st_name: u32 = du32(buf, s_p + SY_NAME);
|
||||
let nm_p: *u8 = dynstr + (st_name: u64);
|
||||
if (nm_p[0u64] == 0u8) {
|
||||
let stname: u32 = du32(buf, sp + SY_NAME);
|
||||
let nmp: *u8 = dynstr + (stname: u64);
|
||||
if (nmp[0u64] == 0u8) {
|
||||
si += 1u64;
|
||||
continue;
|
||||
};
|
||||
|
||||
// Determine version. Skip non-default (hidden) and
|
||||
// local entries.
|
||||
let vername_cs: *u8 = nil;
|
||||
let vernamecs: *u8 = nil;
|
||||
let keep: i32 = 1;
|
||||
if (has_versym != 0) {
|
||||
let v: u16 = du16(buf, versym_off + si * 2u64);
|
||||
if (hasversym != 0) {
|
||||
let v: u16 = du16(buf, versymoff + si * 2u64);
|
||||
if ((v & VERSYM_HIDDEN_C) != 0u16) {
|
||||
keep = 0; // non-default
|
||||
} else {
|
||||
@@ -316,17 +316,17 @@ export fn loadso(l: *lnk, path: *u8) i32 = {
|
||||
if (vidx == VER_NDX_LOCAL_C) {
|
||||
keep = 0; // not exported
|
||||
} else { if (vidx == VER_NDX_GLOBAL_C) {
|
||||
vername_cs = nil;
|
||||
vernamecs = nil;
|
||||
} else { if (vidx == 1u16) {
|
||||
// glibc's BASE entry: treat as
|
||||
// unversioned. (The C version
|
||||
// notes that vidx==1 in Verdef
|
||||
// maps to the SONAME BASE.)
|
||||
vername_cs = nil;
|
||||
vernamecs = nil;
|
||||
} else {
|
||||
if (verstr != nil) {
|
||||
let nm: *u8 = vdnameat(buf, verdef_off, verdef_size, verstr, vidx);
|
||||
vername_cs = nm;
|
||||
let nm: *u8 = vdnameat(buf, verdefoff, verdefsize, verstr, vidx);
|
||||
vernamecs = nm;
|
||||
};
|
||||
}; }; };
|
||||
};
|
||||
@@ -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 = dcstrtostr(l.a, nm_p);
|
||||
if (vername_cs == nil) {
|
||||
e.name = dcstrtostr(l.a, nmp);
|
||||
if (vernamecs == nil) {
|
||||
e.version.ptr = nil;
|
||||
e.version.len = 0i32;
|
||||
} else {
|
||||
e.version = dcstrtostr(l.a, vername_cs);
|
||||
e.version = dcstrtostr(l.a, vernamecs);
|
||||
};
|
||||
e.enext = nil;
|
||||
if (tail == nil) {
|
||||
|
||||
@@ -203,10 +203,10 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = {
|
||||
};
|
||||
|
||||
// ---- collect used .so's (in l.sos order) ----
|
||||
let max_sos: i32 = 0;
|
||||
let maxsos: i32 = 0;
|
||||
let so: *lso = l.sos;
|
||||
for (so != nil) { max_sos += 1; so = so.sonext; };
|
||||
let sos_used: **lso = amalloc(a, (max_sos: u64) * 8u64): **lso;
|
||||
for (so != nil) { maxsos += 1; so = so.sonext; };
|
||||
let sosused: **lso = amalloc(a, (maxsos: u64) * 8u64): **lso;
|
||||
let nsos: i32 = 0;
|
||||
so = l.sos;
|
||||
for (so != nil) {
|
||||
@@ -219,7 +219,7 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = {
|
||||
else { j += 1; };
|
||||
};
|
||||
if (used != 0) {
|
||||
sos_used[nsos] = so;
|
||||
sosused[nsos] = so;
|
||||
nsos += 1;
|
||||
};
|
||||
so = so.sonext;
|
||||
@@ -235,155 +235,155 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = {
|
||||
// ver_dynstr_off[v] = offset within .dynstr (assigned after layout).
|
||||
// ver_vna_other[v] = versym index (starting at 2).
|
||||
|
||||
let vlib_sos_idx_buf: *u8 = amalloc(a, (max_sos: u64) * 4u64): *u8;
|
||||
let vlib_first_buf: *u8 = amalloc(a, (max_sos: u64) * 4u64): *u8;
|
||||
let vlib_count_buf: *u8 = amalloc(a, (max_sos: u64) * 4u64): *u8;
|
||||
let n_vlibs: i32 = 0;
|
||||
let vlibsosidxbuf: *u8 = amalloc(a, (maxsos: u64) * 4u64): *u8;
|
||||
let vlibfirstbuf: *u8 = amalloc(a, (maxsos: u64) * 4u64): *u8;
|
||||
let vlibcountbuf: *u8 = amalloc(a, (maxsos: u64) * 4u64): *u8;
|
||||
let nvlibs: i32 = 0;
|
||||
|
||||
let ver_lib_idx_buf: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
let ver_name_ptr_arr: **u8 = amalloc(a, nu * 8u64): **u8;
|
||||
let ver_name_len_buf: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
let ver_dynstr_off: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
let ver_vna_other: *u8 = amalloc(a, nu * 2u64): *u8;
|
||||
let n_vers: i32 = 0;
|
||||
let verlibidxbuf: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
let vernameptrarr: **u8 = amalloc(a, nu * 8u64): **u8;
|
||||
let vernamelenbuf: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
let verdynstroff: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
let vervnaother: *u8 = amalloc(a, nu * 2u64): *u8;
|
||||
let nvers: i32 = 0;
|
||||
|
||||
let si: i32 = 0;
|
||||
for (si < nsos) {
|
||||
let cur_so: *lso = sos_used[si];
|
||||
let curso: *lso = sosused[si];
|
||||
let has: i32 = 0;
|
||||
let j: i32 = 0;
|
||||
for (j < n) {
|
||||
let dsm: *lsym = dynsyms[j];
|
||||
let dl: *lso = dsm.dynlib;
|
||||
if (dl == cur_so) {
|
||||
if (dl == curso) {
|
||||
let nm0: str = dsm.name;
|
||||
let dv: str = soversion(cur_so, nm0);
|
||||
let dv: str = soversion(curso, nm0);
|
||||
if (dv.len > 0) {
|
||||
has = 1; j = n;
|
||||
} else { j += 1; };
|
||||
} else { j += 1; };
|
||||
};
|
||||
if (has != 0) {
|
||||
dwr32(vlib_sos_idx_buf, (n_vlibs: u64) * 4u64, si: u32);
|
||||
dwr32(vlib_first_buf, (n_vlibs: u64) * 4u64, n_vers: u32);
|
||||
dwr32(vlibsosidxbuf, (nvlibs: u64) * 4u64, si: u32);
|
||||
dwr32(vlibfirstbuf, (nvlibs: u64) * 4u64, nvers: u32);
|
||||
let added: i32 = 0;
|
||||
let jj: i32 = 0;
|
||||
for (jj < n) {
|
||||
let dsm2: *lsym = dynsyms[jj];
|
||||
let dl2: *lso = dsm2.dynlib;
|
||||
if (dl2 == cur_so) {
|
||||
if (dl2 == curso) {
|
||||
let nm2: str = dsm2.name;
|
||||
let vname: str = soversion(cur_so, nm2);
|
||||
let vname: str = soversion(curso, nm2);
|
||||
if (vname.len > 0) {
|
||||
let seen: i32 = 0;
|
||||
let k: i32 = 0;
|
||||
for (k < added) {
|
||||
let kk: i32 = n_vers - added + k;
|
||||
let kk: i32 = nvers - added + k;
|
||||
let existing: str;
|
||||
existing.ptr = ver_name_ptr_arr[kk];
|
||||
existing.len = drdi32(ver_name_len_buf, (kk: u64) * 4u64);
|
||||
existing.ptr = vernameptrarr[kk];
|
||||
existing.len = drdi32(vernamelenbuf, (kk: u64) * 4u64);
|
||||
if (streqd(existing, vname)) {
|
||||
seen = 1; k = added;
|
||||
} else { k += 1; };
|
||||
};
|
||||
if (seen == 0) {
|
||||
dwr32(ver_lib_idx_buf, (n_vers: u64) * 4u64, n_vlibs: u32);
|
||||
ver_name_ptr_arr[n_vers] = vname.ptr;
|
||||
dwri32(ver_name_len_buf, (n_vers: u64) * 4u64, vname.len);
|
||||
n_vers += 1;
|
||||
dwr32(verlibidxbuf, (nvers: u64) * 4u64, nvlibs: u32);
|
||||
vernameptrarr[nvers] = vname.ptr;
|
||||
dwri32(vernamelenbuf, (nvers: u64) * 4u64, vname.len);
|
||||
nvers += 1;
|
||||
added += 1;
|
||||
};
|
||||
};
|
||||
};
|
||||
jj += 1;
|
||||
};
|
||||
dwr32(vlib_count_buf, (n_vlibs: u64) * 4u64, added: u32);
|
||||
n_vlibs += 1;
|
||||
dwr32(vlibcountbuf, (nvlibs: u64) * 4u64, added: u32);
|
||||
nvlibs += 1;
|
||||
};
|
||||
si += 1;
|
||||
};
|
||||
|
||||
// Assign vna_other indices starting at 2, walking vlib then per-version.
|
||||
let next_vna: u16 = 2u16;
|
||||
let nextvna: u16 = 2u16;
|
||||
let vi: i32 = 0;
|
||||
for (vi < n_vlibs) {
|
||||
let first: i32 = drdi32(vlib_first_buf, (vi: u64) * 4u64);
|
||||
let cnt: i32 = drdi32(vlib_count_buf, (vi: u64) * 4u64);
|
||||
for (vi < nvlibs) {
|
||||
let first: i32 = drdi32(vlibfirstbuf, (vi: u64) * 4u64);
|
||||
let cnt: i32 = drdi32(vlibcountbuf, (vi: u64) * 4u64);
|
||||
let k: i32 = 0;
|
||||
for (k < cnt) {
|
||||
dwr16(ver_vna_other, ((first + k): u64) * 2u64, next_vna);
|
||||
next_vna += 1u16;
|
||||
dwr16(vervnaother, ((first + k): u64) * 2u64, nextvna);
|
||||
nextvna += 1u16;
|
||||
k += 1;
|
||||
};
|
||||
vi += 1;
|
||||
};
|
||||
|
||||
// ---- compute dynstr size ----
|
||||
let dynstr_sz: u64 = 1u64; // leading NUL
|
||||
let dynstrsz: u64 = 1u64; // leading NUL
|
||||
let pi: i32 = 0;
|
||||
for (pi < nsos) {
|
||||
let so4: *lso = sos_used[pi];
|
||||
dynstr_sz += so4.soname.len: u64;
|
||||
dynstr_sz += 1u64;
|
||||
let so4: *lso = sosused[pi];
|
||||
dynstrsz += so4.soname.len: u64;
|
||||
dynstrsz += 1u64;
|
||||
pi += 1;
|
||||
};
|
||||
pi = 0;
|
||||
for (pi < n) {
|
||||
let dsm4: *lsym = dynsyms[pi];
|
||||
dynstr_sz += dsm4.name.len: u64;
|
||||
dynstr_sz += 1u64;
|
||||
dynstrsz += dsm4.name.len: u64;
|
||||
dynstrsz += 1u64;
|
||||
pi += 1;
|
||||
};
|
||||
pi = 0;
|
||||
for (pi < n_vers) {
|
||||
let nm_len: i32 = drdi32(ver_name_len_buf, (pi: u64) * 4u64);
|
||||
dynstr_sz += nm_len: u64;
|
||||
dynstr_sz += 1u64;
|
||||
for (pi < nvers) {
|
||||
let nmlen: i32 = drdi32(vernamelenbuf, (pi: u64) * 4u64);
|
||||
dynstrsz += nmlen: u64;
|
||||
dynstrsz += 1u64;
|
||||
pi += 1;
|
||||
};
|
||||
|
||||
// ---- fill dynstr ----
|
||||
let dynstr: *u8 = amalloc(a, dynstr_sz): *u8;
|
||||
let dynstr_pos: u64 = 1u64; // past leading NUL
|
||||
let dynstr: *u8 = amalloc(a, dynstrsz): *u8;
|
||||
let dynstrpos: u64 = 1u64; // past leading NUL
|
||||
|
||||
let soname_str: *u8 = amalloc(a, (nsos: u64) * 4u64): *u8;
|
||||
let sonamestr: *u8 = amalloc(a, (nsos: u64) * 4u64): *u8;
|
||||
pi = 0;
|
||||
for (pi < nsos) {
|
||||
dwr32(soname_str, (pi: u64) * 4u64, dynstr_pos: u32);
|
||||
let so2: *lso = sos_used[pi];
|
||||
dwr32(sonamestr, (pi: u64) * 4u64, dynstrpos: u32);
|
||||
let so2: *lso = sosused[pi];
|
||||
let snm: str = so2.soname;
|
||||
dbcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64);
|
||||
dynstr_pos += snm.len: u64;
|
||||
dynstr[dynstr_pos] = 0u8;
|
||||
dynstr_pos += 1u64;
|
||||
dbcopy(dynstr, dynstrpos, snm.ptr, snm.len: u64);
|
||||
dynstrpos += snm.len: u64;
|
||||
dynstr[dynstrpos] = 0u8;
|
||||
dynstrpos += 1u64;
|
||||
pi += 1;
|
||||
};
|
||||
let symname_str: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
let symnamestr: *u8 = amalloc(a, nu * 4u64): *u8;
|
||||
pi = 0;
|
||||
for (pi < n) {
|
||||
dwr32(symname_str, (pi: u64) * 4u64, dynstr_pos: u32);
|
||||
dwr32(symnamestr, (pi: u64) * 4u64, dynstrpos: u32);
|
||||
let dsm: *lsym = dynsyms[pi];
|
||||
let snm: str = dsm.name;
|
||||
dbcopy(dynstr, dynstr_pos, snm.ptr, snm.len: u64);
|
||||
dynstr_pos += snm.len: u64;
|
||||
dynstr[dynstr_pos] = 0u8;
|
||||
dynstr_pos += 1u64;
|
||||
dbcopy(dynstr, dynstrpos, snm.ptr, snm.len: u64);
|
||||
dynstrpos += snm.len: u64;
|
||||
dynstr[dynstrpos] = 0u8;
|
||||
dynstrpos += 1u64;
|
||||
pi += 1;
|
||||
};
|
||||
pi = 0;
|
||||
for (pi < n_vers) {
|
||||
dwr32(ver_dynstr_off, (pi: u64) * 4u64, dynstr_pos: u32);
|
||||
let nm_p: *u8 = ver_name_ptr_arr[pi];
|
||||
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;
|
||||
for (pi < nvers) {
|
||||
dwr32(verdynstroff, (pi: u64) * 4u64, dynstrpos: u32);
|
||||
let nmp: *u8 = vernameptrarr[pi];
|
||||
let nmlen: i32 = drdi32(vernamelenbuf, (pi: u64) * 4u64);
|
||||
dbcopy(dynstr, dynstrpos, nmp, nmlen: u64);
|
||||
dynstrpos += nmlen: u64;
|
||||
dynstr[dynstrpos] = 0u8;
|
||||
dynstrpos += 1u64;
|
||||
pi += 1;
|
||||
};
|
||||
|
||||
// ---- per-dyn-sym versym index ----
|
||||
let versym_for: *u8 = amalloc(a, nu * 2u64): *u8;
|
||||
let versymfor: *u8 = amalloc(a, nu * 2u64): *u8;
|
||||
pi = 0;
|
||||
for (pi < n) {
|
||||
let dsm3: *lsym = dynsyms[pi];
|
||||
@@ -391,235 +391,235 @@ 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) {
|
||||
dwr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D);
|
||||
dwr16(versymfor, (pi: u64) * 2u64, VER_NDX_GLOBAL_D);
|
||||
} else {
|
||||
let matched: i32 = 0;
|
||||
let vk: i32 = 0;
|
||||
for (vk < n_vers) {
|
||||
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) {
|
||||
for (vk < nvers) {
|
||||
let vlx: i32 = drdi32(verlibidxbuf, (vk: u64) * 4u64);
|
||||
let sosx: i32 = drdi32(vlibsosidxbuf, (vlx: u64) * 4u64);
|
||||
if (sosused[sosx] == dl3) {
|
||||
let exi: str;
|
||||
exi.ptr = ver_name_ptr_arr[vk];
|
||||
exi.len = drdi32(ver_name_len_buf, (vk: u64) * 4u64);
|
||||
exi.ptr = vernameptrarr[vk];
|
||||
exi.len = drdi32(vernamelenbuf, (vk: u64) * 4u64);
|
||||
if (streqd(exi, vname)) {
|
||||
let other: u16 = drdu16(ver_vna_other, (vk: u64) * 2u64);
|
||||
dwr16(versym_for, (pi: u64) * 2u64, other);
|
||||
let other: u16 = drdu16(vervnaother, (vk: u64) * 2u64);
|
||||
dwr16(versymfor, (pi: u64) * 2u64, other);
|
||||
matched = 1;
|
||||
vk = n_vers;
|
||||
vk = nvers;
|
||||
} else { vk += 1; };
|
||||
} else { vk += 1; };
|
||||
};
|
||||
if (matched == 0) {
|
||||
dwr16(versym_for, (pi: u64) * 2u64, VER_NDX_GLOBAL_D);
|
||||
dwr16(versymfor, (pi: u64) * 2u64, VER_NDX_GLOBAL_D);
|
||||
};
|
||||
};
|
||||
pi += 1;
|
||||
};
|
||||
|
||||
// ---- compute byte sizes ----
|
||||
let ehdr_sz: u64 = 64u64;
|
||||
let n_phdrs: u64 = 4u64;
|
||||
let phdr_sz: u64 = n_phdrs * 56u64;
|
||||
let is_local: str = interpstrv();
|
||||
let interp_sz: u64 = (is_local.len: u64) + 1u64;
|
||||
let ehdrsz: u64 = 64u64;
|
||||
let nphdrs: u64 = 4u64;
|
||||
let phdrsz: u64 = nphdrs * 56u64;
|
||||
let islocal: str = interpstrv();
|
||||
let interpsz: u64 = (islocal.len: u64) + 1u64;
|
||||
|
||||
let nsyms_total: u64 = 1u64 + nu;
|
||||
let dynsym_sz: u64 = nsyms_total * 24u64;
|
||||
let nsymstotal: u64 = 1u64 + nu;
|
||||
let dynsymsz: u64 = nsymstotal * 24u64;
|
||||
|
||||
let nbuckets: u32 = 1u32;
|
||||
let nchain: u32 = nsyms_total: u32;
|
||||
let hash_sz: u64 = (2u64 + (nbuckets: u64) + (nchain: u64)) * 4u64;
|
||||
let nchain: u32 = nsymstotal: u32;
|
||||
let hashsz: u64 = (2u64 + (nbuckets: u64) + (nchain: u64)) * 4u64;
|
||||
|
||||
let relaplt_sz: u64 = nu * 24u64;
|
||||
let plt_sz: u64 = nu * PLT_STUB_BYTES_D;
|
||||
let gotplt_sz: u64 = (3u64 + nu) * 8u64;
|
||||
let versym_sz: u64 = nsyms_total * 2u64;
|
||||
let relapltsz: u64 = nu * 24u64;
|
||||
let pltsz: u64 = nu * PLT_STUB_BYTES_D;
|
||||
let gotpltsz: u64 = (3u64 + nu) * 8u64;
|
||||
let versymsz: u64 = nsymstotal * 2u64;
|
||||
|
||||
let verneed_sz: u64 = 0u64;
|
||||
let verneedsz: u64 = 0u64;
|
||||
let vli: i32 = 0;
|
||||
for (vli < n_vlibs) {
|
||||
let cnt: i32 = drdi32(vlib_count_buf, (vli: u64) * 4u64);
|
||||
verneed_sz += 16u64 + 16u64 * (cnt: u64);
|
||||
for (vli < nvlibs) {
|
||||
let cnt: i32 = drdi32(vlibcountbuf, (vli: u64) * 4u64);
|
||||
verneedsz += 16u64 + 16u64 * (cnt: u64);
|
||||
vli += 1;
|
||||
};
|
||||
|
||||
let with_ver: i32 = 0;
|
||||
if (n_vlibs > 0) { with_ver = 1; };
|
||||
let withver: i32 = 0;
|
||||
if (nvlibs > 0) { withver = 1; };
|
||||
let extra: u64 = 0u64;
|
||||
if (with_ver != 0) { extra = 3u64; };
|
||||
if (withver != 0) { extra = 3u64; };
|
||||
let ndyn: u64 = (nsos: u64) + 11u64 + extra;
|
||||
let dynamic_sz: u64 = ndyn * 16u64;
|
||||
let dynamicsz: u64 = ndyn * 16u64;
|
||||
|
||||
// ---- compute file offsets ----
|
||||
let off: u64 = ehdr_sz + phdr_sz;
|
||||
let interp_off: u64 = off; off += interp_sz;
|
||||
let off: u64 = ehdrsz + phdrsz;
|
||||
let interpoff: u64 = off; off += interpsz;
|
||||
off = alignup(off, 8u64);
|
||||
let dynstr_off: u64 = off; off += dynstr_sz;
|
||||
let dynstroff: u64 = off; off += dynstrsz;
|
||||
off = alignup(off, 8u64);
|
||||
let dynsym_off: u64 = off; off += dynsym_sz;
|
||||
let hash_off: u64 = off; off += hash_sz;
|
||||
let dynsymoff: u64 = off; off += dynsymsz;
|
||||
let hashoff: u64 = off; off += hashsz;
|
||||
off = alignup(off, 2u64);
|
||||
let versym_off: u64 = off; off += versym_sz;
|
||||
let versymoff: u64 = off; off += versymsz;
|
||||
off = alignup(off, 4u64);
|
||||
let verneed_off: u64 = off; off += verneed_sz;
|
||||
let verneedoff: u64 = off; off += verneedsz;
|
||||
off = alignup(off, 8u64);
|
||||
let relaplt_off: u64 = off; off += relaplt_sz;
|
||||
let relapltoff: u64 = off; off += relapltsz;
|
||||
|
||||
let text_off: u64 = alignup(off, PAGE);
|
||||
let plt_off: u64 = text_off + l.textlen;
|
||||
let rx_end: u64 = plt_off + plt_sz;
|
||||
let textoff: u64 = alignup(off, PAGE);
|
||||
let pltoff: u64 = textoff + l.textlen;
|
||||
let rxend: u64 = pltoff + pltsz;
|
||||
|
||||
let gotplt_off: u64 = alignup(rx_end, PAGE);
|
||||
let dynamic_off: u64 = gotplt_off + gotplt_sz;
|
||||
let file_end: u64 = dynamic_off + dynamic_sz;
|
||||
let gotpltoff: u64 = alignup(rxend, PAGE);
|
||||
let dynamicoff: u64 = gotpltoff + gotpltsz;
|
||||
let fileend: u64 = dynamicoff + dynamicsz;
|
||||
|
||||
let interp_va: u64 = base + interp_off;
|
||||
let dynstr_va: u64 = base + dynstr_off;
|
||||
let dynsym_va: u64 = base + dynsym_off;
|
||||
let hash_va: u64 = base + hash_off;
|
||||
let versym_va: u64 = base + versym_off;
|
||||
let verneed_va: u64 = base + verneed_off;
|
||||
let relaplt_va: u64 = base + relaplt_off;
|
||||
let text_va: u64 = base + text_off;
|
||||
let plt_va: u64 = base + plt_off;
|
||||
let gotplt_va: u64 = base + gotplt_off;
|
||||
let dynamic_va: u64 = base + dynamic_off;
|
||||
let interpva: u64 = base + interpoff;
|
||||
let dynstrva: u64 = base + dynstroff;
|
||||
let dynsymva: u64 = base + dynsymoff;
|
||||
let hashva: u64 = base + hashoff;
|
||||
let versymva: u64 = base + versymoff;
|
||||
let verneedva: u64 = base + verneedoff;
|
||||
let relapltva: u64 = base + relapltoff;
|
||||
let textva: u64 = base + textoff;
|
||||
let pltva: u64 = base + pltoff;
|
||||
let gotpltva: u64 = base + gotpltoff;
|
||||
let dynamicva: u64 = base + dynamicoff;
|
||||
|
||||
// ---- build .dynsym ----
|
||||
let dynsym_buf: *u8 = amalloc(a, dynsym_sz): *u8;
|
||||
let dynsymbuf: *u8 = amalloc(a, dynsymsz): *u8;
|
||||
pi = 0;
|
||||
for (pi < n) {
|
||||
let eoff: u64 = (1u64 + (pi: u64)) * 24u64;
|
||||
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);
|
||||
dwr32(dynsymbuf, eoff + 0u64, drdu32(symnamestr, (pi: u64) * 4u64));
|
||||
dwr8(dynsymbuf, eoff + 4u64, (STB_GLOBAL_D << 4u8) | (STT_FUNC_D & 15u8));
|
||||
dwr8(dynsymbuf, eoff + 5u64, 0u8);
|
||||
dwr16(dynsymbuf, eoff + 6u64, 0u16);
|
||||
dwr64(dynsymbuf, eoff + 8u64, 0u64);
|
||||
dwr64(dynsymbuf, eoff + 16u64, 0u64);
|
||||
pi += 1;
|
||||
};
|
||||
|
||||
// ---- build .hash (SysV, 1 bucket) ----
|
||||
let hash_buf: *u8 = amalloc(a, hash_sz): *u8;
|
||||
dwr32(hash_buf, 0u64, nbuckets);
|
||||
dwr32(hash_buf, 4u64, nchain);
|
||||
let hashbuf: *u8 = amalloc(a, hashsz): *u8;
|
||||
dwr32(hashbuf, 0u64, nbuckets);
|
||||
dwr32(hashbuf, 4u64, nchain);
|
||||
let bucket0: u32 = 0u32;
|
||||
if (nsyms_total > 1u64) { bucket0 = 1u32; };
|
||||
dwr32(hash_buf, 8u64, bucket0);
|
||||
if (nsymstotal > 1u64) { bucket0 = 1u32; };
|
||||
dwr32(hashbuf, 8u64, bucket0);
|
||||
let ci: u64 = 1u64;
|
||||
for (ci < nsyms_total) {
|
||||
for (ci < nsymstotal) {
|
||||
let nxt: u32 = 0u32;
|
||||
if (ci + 1u64 < nsyms_total) { nxt = (ci + 1u64): u32; };
|
||||
dwr32(hash_buf, 8u64 + (nbuckets: u64) * 4u64 + ci * 4u64, nxt);
|
||||
if (ci + 1u64 < nsymstotal) { nxt = (ci + 1u64): u32; };
|
||||
dwr32(hashbuf, 8u64 + (nbuckets: u64) * 4u64 + ci * 4u64, nxt);
|
||||
ci += 1u64;
|
||||
};
|
||||
|
||||
// ---- build .rela.plt ----
|
||||
let relaplt_buf: *u8 = amalloc(a, relaplt_sz): *u8;
|
||||
let relapltbuf: *u8 = amalloc(a, relapltsz): *u8;
|
||||
pi = 0;
|
||||
for (pi < n) {
|
||||
let roff: u64 = (pi: u64) * 24u64;
|
||||
dwr64(relaplt_buf, roff + 0u64, gotplt_va + (3u64 + (pi: u64)) * 8u64);
|
||||
dwr64(relapltbuf, roff + 0u64, gotpltva + (3u64 + (pi: u64)) * 8u64);
|
||||
let info: u64 = ((1u64 + (pi: u64)) << 32u64) | (R_X86_64_JUMP_SLOT_D: u64);
|
||||
dwr64(relaplt_buf, roff + 8u64, info);
|
||||
dwri64(relaplt_buf, roff + 16u64, 0i64);
|
||||
dwr64(relapltbuf, roff + 8u64, info);
|
||||
dwri64(relapltbuf, roff + 16u64, 0i64);
|
||||
pi += 1;
|
||||
};
|
||||
|
||||
// ---- build .gnu.version (u16 per dynsym entry) ----
|
||||
let versym_buf: *u8 = amalloc(a, versym_sz): *u8;
|
||||
dwr16(versym_buf, 0u64, VER_NDX_LOCAL_D);
|
||||
let versymbuf: *u8 = amalloc(a, versymsz): *u8;
|
||||
dwr16(versymbuf, 0u64, VER_NDX_LOCAL_D);
|
||||
pi = 0;
|
||||
for (pi < n) {
|
||||
dwr16(versym_buf, 2u64 + (pi: u64) * 2u64, drdu16(versym_for, (pi: u64) * 2u64));
|
||||
dwr16(versymbuf, 2u64 + (pi: u64) * 2u64, drdu16(versymfor, (pi: u64) * 2u64));
|
||||
pi += 1;
|
||||
};
|
||||
|
||||
// ---- build .gnu.version_r ----
|
||||
let verneed_buf: *u8 = amalloc(a, verneed_sz): *u8;
|
||||
if (verneed_sz > 0u64) {
|
||||
let verneedbuf: *u8 = amalloc(a, verneedsz): *u8;
|
||||
if (verneedsz > 0u64) {
|
||||
let vnoff: u64 = 0u64;
|
||||
vli = 0;
|
||||
for (vli < n_vlibs) {
|
||||
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;
|
||||
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);
|
||||
for (vli < nvlibs) {
|
||||
let sosidx: i32 = drdi32(vlibsosidxbuf, (vli: u64) * 4u64);
|
||||
let first: i32 = drdi32(vlibfirstbuf, (vli: u64) * 4u64);
|
||||
let cnt: i32 = drdi32(vlibcountbuf, (vli: u64) * 4u64);
|
||||
let vnstart: u64 = vnoff;
|
||||
dwr16(verneedbuf, vnoff + 0u64, 1u16);
|
||||
dwr16(verneedbuf, vnoff + 2u64, cnt: u16);
|
||||
dwr32(verneedbuf, vnoff + 4u64, drdu32(sonamestr, (sosidx: u64) * 4u64));
|
||||
dwr32(verneedbuf, 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 = drdi32(ver_name_len_buf, (vk: u64) * 4u64);
|
||||
nm.ptr = vernameptrarr[vk];
|
||||
nm.len = drdi32(vernamelenbuf, (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));
|
||||
dwr32(verneedbuf, vnoff + 0u64, h);
|
||||
dwr16(verneedbuf, vnoff + 4u64, 0u16);
|
||||
dwr16(verneedbuf, vnoff + 6u64, drdu16(vervnaother, (vk: u64) * 2u64));
|
||||
dwr32(verneedbuf, vnoff + 8u64, drdu32(verdynstroff, (vk: u64) * 4u64));
|
||||
let nxt: u32 = 0u32;
|
||||
if (k + 1 < cnt) { nxt = 16u32; };
|
||||
dwr32(verneed_buf, vnoff + 12u64, nxt);
|
||||
dwr32(verneedbuf, vnoff + 12u64, nxt);
|
||||
vnoff += 16u64;
|
||||
k += 1;
|
||||
};
|
||||
let vn_nxt: u32 = 0u32;
|
||||
if (vli + 1 < n_vlibs) { vn_nxt = (vnoff - vn_start): u32; };
|
||||
dwr32(verneed_buf, vn_start + 12u64, vn_nxt);
|
||||
let vnnxt: u32 = 0u32;
|
||||
if (vli + 1 < nvlibs) { vnnxt = (vnoff - vnstart): u32; };
|
||||
dwr32(verneedbuf, vnstart + 12u64, vnnxt);
|
||||
vli += 1;
|
||||
};
|
||||
};
|
||||
|
||||
// ---- build .plt ----
|
||||
let plt_buf: *u8 = amalloc(a, plt_sz): *u8;
|
||||
let pltbuf: *u8 = amalloc(a, pltsz): *u8;
|
||||
pi = 0;
|
||||
for (pi < n) {
|
||||
let p_off: u64 = (pi: u64) * PLT_STUB_BYTES_D;
|
||||
let stub_va: u64 = plt_va + p_off;
|
||||
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);
|
||||
dwr8(plt_buf, p_off + 0u64, 255u8);
|
||||
dwr8(plt_buf, p_off + 1u64, 37u8);
|
||||
dwr32(plt_buf, p_off + 2u64, (disp: i32): u32);
|
||||
let poff: u64 = (pi: u64) * PLT_STUB_BYTES_D;
|
||||
let stubva: u64 = pltva + poff;
|
||||
let nextip: u64 = stubva + 6u64;
|
||||
let slotva: u64 = gotpltva + (3u64 + (pi: u64)) * 8u64;
|
||||
let disp: i64 = (slotva: i64) - (nextip: i64);
|
||||
dwr8(pltbuf, poff + 0u64, 255u8);
|
||||
dwr8(pltbuf, poff + 1u64, 37u8);
|
||||
dwr32(pltbuf, poff + 2u64, (disp: i32): u32);
|
||||
pi += 1;
|
||||
};
|
||||
|
||||
// ---- build .got.plt ----
|
||||
let gotplt_buf: *u8 = amalloc(a, gotplt_sz): *u8;
|
||||
dwr64(gotplt_buf, 0u64, dynamic_va);
|
||||
let gotpltbuf: *u8 = amalloc(a, gotpltsz): *u8;
|
||||
dwr64(gotpltbuf, 0u64, dynamicva);
|
||||
|
||||
// ---- build .dynamic ----
|
||||
let dynamic_buf: *u8 = amalloc(a, dynamic_sz): *u8;
|
||||
let dynamicbuf: *u8 = amalloc(a, dynamicsz): *u8;
|
||||
let dk: u64 = 0u64;
|
||||
pi = 0;
|
||||
for (pi < nsos) {
|
||||
dwri64(dynamic_buf, dk * 16u64 + 0u64, DT_NEEDED);
|
||||
dwr64(dynamic_buf, dk * 16u64 + 8u64, drdu32(soname_str, (pi: u64) * 4u64): u64);
|
||||
dwri64(dynamicbuf, dk * 16u64 + 0u64, DT_NEEDED);
|
||||
dwr64(dynamicbuf, dk * 16u64 + 8u64, drdu32(sonamestr, (pi: u64) * 4u64): u64);
|
||||
dk += 1u64;
|
||||
pi += 1;
|
||||
};
|
||||
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) {
|
||||
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;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_HASH); dwr64(dynamicbuf, dk * 16u64 + 8u64, hashva); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_STRTAB); dwr64(dynamicbuf, dk * 16u64 + 8u64, dynstrva); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_SYMTAB); dwr64(dynamicbuf, dk * 16u64 + 8u64, dynsymva); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_STRSZ); dwr64(dynamicbuf, dk * 16u64 + 8u64, dynstrsz); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_SYMENT); dwr64(dynamicbuf, dk * 16u64 + 8u64, 24u64); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_PLTGOT); dwr64(dynamicbuf, dk * 16u64 + 8u64, gotpltva); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_PLTRELSZ); dwr64(dynamicbuf, dk * 16u64 + 8u64, relapltsz); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_PLTREL); dwr64(dynamicbuf, dk * 16u64 + 8u64, DT_RELA: u64);dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_JMPREL); dwr64(dynamicbuf, dk * 16u64 + 8u64, relapltva); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_BIND_NOW); dwr64(dynamicbuf, dk * 16u64 + 8u64, 0u64); dk += 1u64;
|
||||
if (withver != 0) {
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_VERSYM); dwr64(dynamicbuf, dk * 16u64 + 8u64, versymva); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_VERNEED); dwr64(dynamicbuf, dk * 16u64 + 8u64, verneedva); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_VERNEEDNUM); dwr64(dynamicbuf, dk * 16u64 + 8u64, nvlibs: u64);dk += 1u64;
|
||||
};
|
||||
dwri64(dynamic_buf, dk * 16u64, DT_NULL); dwr64(dynamic_buf, dk * 16u64 + 8u64, 0u64); dk += 1u64;
|
||||
dwri64(dynamicbuf, dk * 16u64, DT_NULL); dwr64(dynamicbuf, dk * 16u64 + 8u64, 0u64); dk += 1u64;
|
||||
if (dk != ndyn) {
|
||||
os.write(2, "w6l: dynamic entry count mismatch\n".ptr, 33u64);
|
||||
return 1;
|
||||
@@ -637,8 +637,8 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = {
|
||||
return 1;
|
||||
};
|
||||
};
|
||||
let site: u64 = text_va + r.off;
|
||||
let stub: u64 = plt_va + (rsym.pltidx: u64) * PLT_STUB_BYTES_D;
|
||||
let site: u64 = textva + r.off;
|
||||
let stub: u64 = pltva + (rsym.pltidx: u64) * PLT_STUB_BYTES_D;
|
||||
let disp: i64 = (stub: i64) - (site: i64) + r.addend;
|
||||
dwr32(l.text, r.off, (disp: i32): u32);
|
||||
};
|
||||
@@ -647,96 +647,96 @@ export fn emitdynelf(l: *lnk, fd: i32, base: u64, entry: u64) i32 = {
|
||||
};
|
||||
|
||||
// ---- assemble file buffer ----
|
||||
let file_buf: *u8 = os.alloc(file_end): *u8;
|
||||
if (file_buf == nil) {
|
||||
let filebuf: *u8 = os.alloc(fileend): *u8;
|
||||
if (filebuf == nil) {
|
||||
os.write(2, "w6l: out of memory\n".ptr, 18u64);
|
||||
return 1;
|
||||
};
|
||||
|
||||
// Ehdr
|
||||
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);
|
||||
dwr8(filebuf, 0u64, 127u8);
|
||||
dwr8(filebuf, 1u64, 69u8);
|
||||
dwr8(filebuf, 2u64, 76u8);
|
||||
dwr8(filebuf, 3u64, 70u8);
|
||||
dwr8(filebuf, 4u64, ELFCLASS64_D);
|
||||
dwr8(filebuf, 5u64, ELFDATA2LSB_D);
|
||||
dwr8(filebuf, 6u64, EV_CURRENT_D: u8);
|
||||
dwr16(filebuf, 16u64, ET_EXEC_D);
|
||||
dwr16(filebuf, 18u64, EM_X86_64_D);
|
||||
dwr32(filebuf, 20u64, EV_CURRENT_D);
|
||||
dwr64(filebuf, 24u64, entry);
|
||||
dwr64(filebuf, 32u64, ehdrsz);
|
||||
dwr64(filebuf, 40u64, 0u64);
|
||||
dwr32(filebuf, 48u64, 0u32);
|
||||
dwr16(filebuf, 52u64, ehdrsz: u16);
|
||||
dwr16(filebuf, 54u64, 56u16);
|
||||
dwr16(filebuf, 56u64, nphdrs: u16);
|
||||
dwr16(filebuf, 58u64, 0u16);
|
||||
dwr16(filebuf, 60u64, 0u16);
|
||||
dwr16(filebuf, 62u64, 0u16);
|
||||
|
||||
// Phdrs at offset 64.
|
||||
let p0: u64 = 64u64;
|
||||
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);
|
||||
dwr32(filebuf, p0 + 0u64, PT_LOAD_D);
|
||||
dwr32(filebuf, p0 + 4u64, PF_R_D | PF_X_D);
|
||||
dwr64(filebuf, p0 + 8u64, 0u64);
|
||||
dwr64(filebuf, p0 + 16u64, base);
|
||||
dwr64(filebuf, p0 + 24u64, base);
|
||||
dwr64(filebuf, p0 + 32u64, rxend);
|
||||
dwr64(filebuf, p0 + 40u64, rxend);
|
||||
dwr64(filebuf, p0 + 48u64, PAGE);
|
||||
|
||||
let p1: u64 = 64u64 + 56u64;
|
||||
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);
|
||||
dwr32(filebuf, p1 + 0u64, PT_LOAD_D);
|
||||
dwr32(filebuf, p1 + 4u64, PF_R_D | PF_W_D);
|
||||
dwr64(filebuf, p1 + 8u64, gotpltoff);
|
||||
dwr64(filebuf, p1 + 16u64, gotpltva);
|
||||
dwr64(filebuf, p1 + 24u64, gotpltva);
|
||||
dwr64(filebuf, p1 + 32u64, fileend - gotpltoff);
|
||||
dwr64(filebuf, p1 + 40u64, fileend - gotpltoff);
|
||||
dwr64(filebuf, p1 + 48u64, PAGE);
|
||||
|
||||
let p2: u64 = 64u64 + 112u64;
|
||||
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);
|
||||
dwr32(filebuf, p2 + 0u64, PT_INTERP_D);
|
||||
dwr32(filebuf, p2 + 4u64, PF_R_D);
|
||||
dwr64(filebuf, p2 + 8u64, interpoff);
|
||||
dwr64(filebuf, p2 + 16u64, interpva);
|
||||
dwr64(filebuf, p2 + 24u64, interpva);
|
||||
dwr64(filebuf, p2 + 32u64, interpsz);
|
||||
dwr64(filebuf, p2 + 40u64, interpsz);
|
||||
dwr64(filebuf, p2 + 48u64, 1u64);
|
||||
|
||||
let p3: u64 = 64u64 + 168u64;
|
||||
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);
|
||||
dwr32(filebuf, p3 + 0u64, PT_DYNAMIC_D);
|
||||
dwr32(filebuf, p3 + 4u64, PF_R_D | PF_W_D);
|
||||
dwr64(filebuf, p3 + 8u64, dynamicoff);
|
||||
dwr64(filebuf, p3 + 16u64, dynamicva);
|
||||
dwr64(filebuf, p3 + 24u64, dynamicva);
|
||||
dwr64(filebuf, p3 + 32u64, dynamicsz);
|
||||
dwr64(filebuf, p3 + 40u64, dynamicsz);
|
||||
dwr64(filebuf, p3 + 48u64, 8u64);
|
||||
|
||||
// Sections.
|
||||
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) {
|
||||
dbcopy(file_buf, verneed_off, verneed_buf, verneed_sz);
|
||||
let interplocal: str = interpstrv();
|
||||
dbcopy(filebuf, interpoff, interplocal.ptr, interplocal.len: u64);
|
||||
dwr8(filebuf, interpoff + (interplocal.len: u64), 0u8);
|
||||
dbcopy(filebuf, dynstroff, dynstr, dynstrsz);
|
||||
dbcopy(filebuf, dynsymoff, dynsymbuf, dynsymsz);
|
||||
dbcopy(filebuf, hashoff, hashbuf, hashsz);
|
||||
dbcopy(filebuf, versymoff, versymbuf, versymsz);
|
||||
if (verneedsz > 0u64) {
|
||||
dbcopy(filebuf, verneedoff, verneedbuf, verneedsz);
|
||||
};
|
||||
dbcopy(file_buf, relaplt_off, relaplt_buf, relaplt_sz);
|
||||
dbcopy(filebuf, relapltoff, relapltbuf, relapltsz);
|
||||
if (l.textlen > 0u64) {
|
||||
dbcopy(file_buf, text_off, l.text, l.textlen);
|
||||
dbcopy(filebuf, textoff, l.text, l.textlen);
|
||||
};
|
||||
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);
|
||||
dbcopy(filebuf, pltoff, pltbuf, pltsz);
|
||||
dbcopy(filebuf, gotpltoff, gotpltbuf, gotpltsz);
|
||||
dbcopy(filebuf, dynamicoff, dynamicbuf, dynamicsz);
|
||||
|
||||
let wrote: i64 = os.writefull(fd, file_buf, file_end);
|
||||
if (wrote != file_end: i64) {
|
||||
let wrote: i64 = os.writefull(fd, filebuf, fileend);
|
||||
if (wrote != fileend: i64) {
|
||||
return 1;
|
||||
};
|
||||
return 0;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -200,51 +200,51 @@ fn elfglobals(a: *arena, buf: *u8, len: u64) *defent = {
|
||||
let shnum: u32 = rdu16(buf, EHDR_SHNUM): u32;
|
||||
let shstrndx: u32 = rdu16(buf, EHDR_SHSTRNDX): u32;
|
||||
|
||||
let shstr_sh_off: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
|
||||
let shstr: *u8 = buf + shstr_sh_off;
|
||||
let shstrshoff: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
|
||||
let shstr: *u8 = buf + shstrshoff;
|
||||
|
||||
let idx_text: i32 = -1;
|
||||
let idx_symtab: i32 = -1;
|
||||
let idxtext: i32 = -1;
|
||||
let idxsymtab: i32 = -1;
|
||||
let i: u32 = 0u32;
|
||||
for (i < shnum) {
|
||||
let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE;
|
||||
let sh_type: u32 = rdu32(buf, sh_off + SHDR_TYPE);
|
||||
let sh_name: u32 = rdu32(buf, sh_off + SHDR_NAME);
|
||||
let nm: *u8 = shstr + (sh_name: u64);
|
||||
if (sh_type == SHT_PROGBITS: u32) {
|
||||
if (cstreq(nm, ".text")) { idx_text = i: i32; };
|
||||
let secoff: u64 = shoff + (i: u64) * SHDR_SIZE;
|
||||
let shtype: u32 = rdu32(buf, secoff + SHDR_TYPE);
|
||||
let shname: u32 = rdu32(buf, secoff + SHDR_NAME);
|
||||
let nm: *u8 = shstr + (shname: u64);
|
||||
if (shtype == SHT_PROGBITS: u32) {
|
||||
if (cstreq(nm, ".text")) { idxtext = i: i32; };
|
||||
};
|
||||
if (sh_type == SHT_SYMTAB: u32) { idx_symtab = i: i32; };
|
||||
if (shtype == SHT_SYMTAB: u32) { idxsymtab = i: i32; };
|
||||
i += 1u32;
|
||||
};
|
||||
if (idx_text < 0) { return nil; };
|
||||
if (idx_symtab < 0) { return nil; };
|
||||
if (idxtext < 0) { return nil; };
|
||||
if (idxsymtab < 0) { return nil; };
|
||||
|
||||
let sym_sh: u64 = shoff + (idx_symtab: u64) * SHDR_SIZE;
|
||||
let sym_off: u64 = rdu64(buf, sym_sh + SHDR_OFFSET);
|
||||
let sym_size: u64 = rdu64(buf, sym_sh + SHDR_SIZE_F);
|
||||
let sym_link: u32 = rdu32(buf, sym_sh + SHDR_LINK);
|
||||
let nsyms: u64 = sym_size / SYM_SIZE;
|
||||
let symsh: u64 = shoff + (idxsymtab: u64) * SHDR_SIZE;
|
||||
let symoff: u64 = rdu64(buf, symsh + SHDR_OFFSET);
|
||||
let symsize: u64 = rdu64(buf, symsh + SHDR_SIZE_F);
|
||||
let symlink: u32 = rdu32(buf, symsh + SHDR_LINK);
|
||||
let nsyms: u64 = symsize / SYM_SIZE;
|
||||
|
||||
let str_sh: u64 = shoff + (sym_link: u64) * SHDR_SIZE;
|
||||
let str_off: u64 = rdu64(buf, str_sh + SHDR_OFFSET);
|
||||
let strtab: *u8 = buf + str_off;
|
||||
let strsh: u64 = shoff + (symlink: u64) * SHDR_SIZE;
|
||||
let stroff: u64 = rdu64(buf, strsh + SHDR_OFFSET);
|
||||
let strtab: *u8 = buf + stroff;
|
||||
|
||||
let head: *defent = nil;
|
||||
let si: u64 = 1u64;
|
||||
for (si < nsyms) {
|
||||
let sym_p: u64 = sym_off + si * SYM_SIZE;
|
||||
let st_name: u32 = rdu32(buf, sym_p + SYM_NAME);
|
||||
let st_info: u8 = buf[sym_p + SYM_INFO];
|
||||
let st_shndx: u16 = rdu16(buf, sym_p + SYM_SHNDX);
|
||||
let bind: u32 = (st_info: u32) >> 4u32;
|
||||
let symp: u64 = symoff + si * SYM_SIZE;
|
||||
let stname: u32 = rdu32(buf, symp + SYM_NAME);
|
||||
let stinfo: u8 = buf[symp + SYM_INFO];
|
||||
let stshndx: u16 = rdu16(buf, symp + SYM_SHNDX);
|
||||
let bind: u32 = (stinfo: u32) >> 4u32;
|
||||
// STB_GLOBAL = 1; defined in .text.
|
||||
if (bind == 1u32) {
|
||||
if (st_shndx != 0u16) {
|
||||
if ((st_shndx: i32) == idx_text) {
|
||||
let nm_p: *u8 = strtab + (st_name: u64);
|
||||
if (nm_p[0u64] != 0u8) {
|
||||
let nm: str = cstrtostr(a, nm_p);
|
||||
if (stshndx != 0u16) {
|
||||
if ((stshndx: i32) == idxtext) {
|
||||
let nmp: *u8 = strtab + (stname: u64);
|
||||
if (nmp[0u64] != 0u8) {
|
||||
let nm: str = cstrtostr(a, nmp);
|
||||
let de: *defent = amalloc(a, 32u64): *defent;
|
||||
de.name = nm;
|
||||
de.dnext = head;
|
||||
@@ -283,31 +283,31 @@ fn loadarchive(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = {
|
||||
let tail: *armember = nil;
|
||||
let pos: u64 = 8u64; // past "!<arch>\n"
|
||||
for (pos + 60u64 <= len) {
|
||||
let hdr_size: u64 = arfield(buf + pos + 48u64, 10u64);
|
||||
let hdr_end: u64 = pos + 60u64;
|
||||
if (hdr_end + hdr_size > len) { break; };
|
||||
let hdrsize: u64 = arfield(buf + pos + 48u64, 10u64);
|
||||
let hdrend: u64 = pos + 60u64;
|
||||
if (hdrend + hdrsize > len) { break; };
|
||||
let first: u8 = buf[pos];
|
||||
// Skip the symbol table ('/'), long-name table ('//'), and
|
||||
// any padding entries (NUL or space leading byte).
|
||||
if (first != 47u8) { if (first != 0u8) { if (first != 32u8) {
|
||||
let m: *armember = amalloc(l.a, 48u64): *armember;
|
||||
m.size = hdr_size;
|
||||
let mb: *u8 = amalloc(l.a, hdr_size): *u8;
|
||||
m.size = hdrsize;
|
||||
let mb: *u8 = amalloc(l.a, hdrsize): *u8;
|
||||
let i: u64 = 0u64;
|
||||
for (i < hdr_size) {
|
||||
mb[i] = buf[hdr_end + i];
|
||||
for (i < hdrsize) {
|
||||
mb[i] = buf[hdrend + i];
|
||||
i += 1u64;
|
||||
};
|
||||
m.data = mb;
|
||||
m.defs = elfglobals(l.a, mb, hdr_size);
|
||||
m.defs = elfglobals(l.a, mb, hdrsize);
|
||||
m.loaded = 0;
|
||||
m.mnext = nil;
|
||||
if (head == nil) { head = m; }
|
||||
else { tail.mnext = m; };
|
||||
tail = m;
|
||||
}; }; };
|
||||
pos = hdr_end + hdr_size;
|
||||
if ((hdr_size & 1u64) != 0u64) { pos = pos + 1u64; };
|
||||
pos = hdrend + hdrsize;
|
||||
if ((hdrsize & 1u64) != 0u64) { pos = pos + 1u64; };
|
||||
};
|
||||
|
||||
let changed: i32 = 1;
|
||||
@@ -360,50 +360,50 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = {
|
||||
let shnum: u32 = rdu16(buf, EHDR_SHNUM): u32;
|
||||
let shstrndx: u32 = rdu16(buf, EHDR_SHSTRNDX): u32;
|
||||
|
||||
let shstr_sh_off: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
|
||||
let shstr: *u8 = buf + shstr_sh_off;
|
||||
let shstrshoff: u64 = rdu64(buf, shoff + (shstrndx: u64) * SHDR_SIZE + SHDR_OFFSET);
|
||||
let shstr: *u8 = buf + shstrshoff;
|
||||
|
||||
// find .text, .symtab, .rela.text
|
||||
let idx_text: i32 = -1;
|
||||
let idx_symtab: i32 = -1;
|
||||
let idx_rela: i32 = -1;
|
||||
let idxtext: i32 = -1;
|
||||
let idxsymtab: i32 = -1;
|
||||
let idxrela: i32 = -1;
|
||||
let i: u32 = 0u32;
|
||||
for (i < shnum) {
|
||||
let sh_off: u64 = shoff + (i: u64) * SHDR_SIZE;
|
||||
let sh_type: u32 = rdu32(buf, sh_off + SHDR_TYPE);
|
||||
let sh_name: u32 = rdu32(buf, sh_off + SHDR_NAME);
|
||||
let nm: *u8 = shstr + (sh_name: u64);
|
||||
if (sh_type == SHT_PROGBITS: u32) {
|
||||
if (cstreq(nm, ".text")) { idx_text = i: i32; };
|
||||
let secoff: u64 = shoff + (i: u64) * SHDR_SIZE;
|
||||
let shtype: u32 = rdu32(buf, secoff + SHDR_TYPE);
|
||||
let shname: u32 = rdu32(buf, secoff + SHDR_NAME);
|
||||
let nm: *u8 = shstr + (shname: u64);
|
||||
if (shtype == SHT_PROGBITS: u32) {
|
||||
if (cstreq(nm, ".text")) { idxtext = i: i32; };
|
||||
};
|
||||
if (sh_type == SHT_SYMTAB: u32) { idx_symtab = i: i32; };
|
||||
if (sh_type == SHT_RELA: u32) {
|
||||
if (cstreq(nm, ".rela.text")) { idx_rela = i: i32; };
|
||||
if (shtype == SHT_SYMTAB: u32) { idxsymtab = i: i32; };
|
||||
if (shtype == SHT_RELA: u32) {
|
||||
if (cstreq(nm, ".rela.text")) { idxrela = i: i32; };
|
||||
};
|
||||
i += 1u32;
|
||||
};
|
||||
if (idx_text < 0) {
|
||||
if (idxtext < 0) {
|
||||
os.write(2, "w6l: missing .text\n".ptr, 18u64);
|
||||
return -1;
|
||||
};
|
||||
if (idx_symtab < 0) {
|
||||
if (idxsymtab < 0) {
|
||||
os.write(2, "w6l: missing .symtab\n".ptr, 20u64);
|
||||
return -1;
|
||||
};
|
||||
|
||||
let text_sh: u64 = shoff + (idx_text: u64) * SHDR_SIZE;
|
||||
let text_off: u64 = rdu64(buf, text_sh + SHDR_OFFSET);
|
||||
let text_size: u64 = rdu64(buf, text_sh + SHDR_SIZE_F);
|
||||
let textsh: u64 = shoff + (idxtext: u64) * SHDR_SIZE;
|
||||
let textoff: u64 = rdu64(buf, textsh + SHDR_OFFSET);
|
||||
let textsize: u64 = rdu64(buf, textsh + SHDR_SIZE_F);
|
||||
|
||||
let sym_sh: u64 = shoff + (idx_symtab: u64) * SHDR_SIZE;
|
||||
let sym_off: u64 = rdu64(buf, sym_sh + SHDR_OFFSET);
|
||||
let sym_size: u64 = rdu64(buf, sym_sh + SHDR_SIZE_F);
|
||||
let sym_link: u32 = rdu32(buf, sym_sh + SHDR_LINK);
|
||||
let nsyms: u64 = sym_size / SYM_SIZE;
|
||||
let symsh: u64 = shoff + (idxsymtab: u64) * SHDR_SIZE;
|
||||
let symoff: u64 = rdu64(buf, symsh + SHDR_OFFSET);
|
||||
let symsize: u64 = rdu64(buf, symsh + SHDR_SIZE_F);
|
||||
let symlink: u32 = rdu32(buf, symsh + SHDR_LINK);
|
||||
let nsyms: u64 = symsize / SYM_SIZE;
|
||||
|
||||
let str_sh: u64 = shoff + (sym_link: u64) * SHDR_SIZE;
|
||||
let str_off: u64 = rdu64(buf, str_sh + SHDR_OFFSET);
|
||||
let strtab: *u8 = buf + str_off;
|
||||
let strsh: u64 = shoff + (symlink: u64) * SHDR_SIZE;
|
||||
let stroff: u64 = rdu64(buf, strsh + SHDR_OFFSET);
|
||||
let strtab: *u8 = buf + stroff;
|
||||
|
||||
// Track this object.
|
||||
let ob: *lobj = amalloc(l.a, 64u64): *lobj;
|
||||
@@ -411,28 +411,28 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = {
|
||||
ob.buf = buf;
|
||||
ob.len = len;
|
||||
ob.textoff = l.textlen;
|
||||
ob.textsize = text_size;
|
||||
ob.textsize = textsize;
|
||||
ob.onext = l.objs;
|
||||
l.objs = ob;
|
||||
|
||||
// Append .text bytes to the combined image.
|
||||
emittext(l, buf + text_off, text_size);
|
||||
emittext(l, buf + textoff, textsize);
|
||||
|
||||
// Walk symbols. We don't keep a per-object map[] of *lsym. Instead
|
||||
// the reloc loop re-walks symtab and re-interns by name. Simpler
|
||||
// than dancing around the cgen's u64-shift gaps.
|
||||
let si: u64 = 1u64; // skip index 0 (always undef sentinel)
|
||||
for (si < nsyms) {
|
||||
let sym_p: u64 = sym_off + si * SYM_SIZE;
|
||||
let st_name: u32 = rdu32(buf, sym_p + SYM_NAME);
|
||||
let st_shndx: u16 = rdu16(buf, sym_p + SYM_SHNDX);
|
||||
let st_value: u64 = rdu64(buf, sym_p + SYM_VALUE);
|
||||
let nm_p: *u8 = strtab + (st_name: u64);
|
||||
if (nm_p[0u64] != 0u8) {
|
||||
let nm: str = cstrtostr(l.a, nm_p);
|
||||
let symp: u64 = symoff + si * SYM_SIZE;
|
||||
let stname: u32 = rdu32(buf, symp + SYM_NAME);
|
||||
let stshndx: u16 = rdu16(buf, symp + SYM_SHNDX);
|
||||
let stvalue: u64 = rdu64(buf, symp + SYM_VALUE);
|
||||
let nmp: *u8 = strtab + (stname: u64);
|
||||
if (nmp[0u64] != 0u8) {
|
||||
let nm: str = cstrtostr(l.a, nmp);
|
||||
let gs: *lsym = intern(l, nm);
|
||||
if (st_shndx != 0u16) {
|
||||
if ((st_shndx: i32) == idx_text) {
|
||||
if (stshndx != 0u16) {
|
||||
if ((stshndx: i32) == idxtext) {
|
||||
if (gs.defined != 0) {
|
||||
os.write(2, "w6l: duplicate symbol\n".ptr, 21u64);
|
||||
l.errs += 1;
|
||||
@@ -440,7 +440,7 @@ fn loadimage(l: *lnk, path: *u8, buf: *u8, len: u64) i32 = {
|
||||
gs.defined = 1;
|
||||
gs.owner = ob;
|
||||
gs.idxinowner = si: i32;
|
||||
gs.val = ob.textoff + st_value;
|
||||
gs.val = ob.textoff + stvalue;
|
||||
};
|
||||
};
|
||||
};
|
||||
@@ -449,30 +449,30 @@ 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 = rdu64(buf, rela_sh + SHDR_OFFSET);
|
||||
let rela_size: u64 = rdu64(buf, rela_sh + SHDR_SIZE_F);
|
||||
let nrel: u64 = rela_size / RELA_SIZE;
|
||||
if (idxrela >= 0) {
|
||||
let relash: u64 = shoff + (idxrela: u64) * SHDR_SIZE;
|
||||
let relaoff: u64 = rdu64(buf, relash + SHDR_OFFSET);
|
||||
let relasize: u64 = rdu64(buf, relash + SHDR_SIZE_F);
|
||||
let nrel: u64 = relasize / RELA_SIZE;
|
||||
let ri: u64 = 0u64;
|
||||
for (ri < nrel) {
|
||||
let rp: u64 = rela_off + ri * RELA_SIZE;
|
||||
let r_off: u64 = rdu64(buf, rp + RELA_OFFSET);
|
||||
let r_info: u64 = rdu64(buf, rp + RELA_INFO);
|
||||
let r_addend: u64 = rdu64(buf, rp + RELA_ADDEND);
|
||||
let r_sym_idx: u32 = (r_info >> 32u64): u32;
|
||||
let r_kind: i32 = ((r_info & 4294967295u64): u32): i32;
|
||||
let rp: u64 = relaoff + ri * RELA_SIZE;
|
||||
let roff: u64 = rdu64(buf, rp + RELA_OFFSET);
|
||||
let rinfo: u64 = rdu64(buf, rp + RELA_INFO);
|
||||
let raddend: u64 = rdu64(buf, rp + RELA_ADDEND);
|
||||
let rsymidx: u32 = (rinfo >> 32u64): u32;
|
||||
let rkind: i32 = ((rinfo & 4294967295u64): u32): i32;
|
||||
let nr: *lrel = amalloc(l.a, 48u64): *lrel;
|
||||
nr.off = ob.textoff + r_off;
|
||||
nr.kind = r_kind;
|
||||
nr.addend = r_addend: i64;
|
||||
nr.off = ob.textoff + roff;
|
||||
nr.kind = rkind;
|
||||
nr.addend = raddend: i64;
|
||||
// Look up the referenced sym by name (re-walk symtab).
|
||||
if ((r_sym_idx: u64) < nsyms) {
|
||||
let s_p: u64 = sym_off + (r_sym_idx: u64) * SYM_SIZE;
|
||||
let s_name: u32 = rdu32(buf, s_p + SYM_NAME);
|
||||
let s_nm: *u8 = strtab + (s_name: u64);
|
||||
if (s_nm[0u64] != 0u8) {
|
||||
let nm: str = cstrtostr(l.a, s_nm);
|
||||
if ((rsymidx: u64) < nsyms) {
|
||||
let sp: u64 = symoff + (rsymidx: u64) * SYM_SIZE;
|
||||
let sname: u32 = rdu32(buf, sp + SYM_NAME);
|
||||
let snm: *u8 = strtab + (sname: u64);
|
||||
if (snm[0u64] != 0u8) {
|
||||
let nm: str = cstrtostr(l.a, snm);
|
||||
nr.sym = intern(l, nm);
|
||||
};
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user