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

selfhost: drop snake_case locals in dyn/dynout/obj + w6a + cgen + ww driver

Browse Source
This commit is contained in:
Hojun-Cho
2026-05-11 16:33:02 +09:00
parent c64e96cbd6
commit 97ca76d2bb
18 changed files with 1795 additions and 1795 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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