summaryrefslogtreecommitdiff
path: root/src/trace/Symbols.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 23:55:42 -0300
committerGabriel Schneider <[email protected]>2026-11-11 00:06:30 -0300
commitc94ade9e77a811d3ff75ffc2889a65375262ab1f (patch)
treecd6e1da77cae54dc1ff4c35ee9d9262549819770 /src/trace/Symbols.zig
parent81d97a9e38c740a96af13a8a981878947a508bc0 (diff)
downloadcomputeranim-c94ade9e77a811d3ff75ffc2889a65375262ab1f.tar.gz
computeranim-c94ade9e77a811d3ff75ffc2889a65375262ab1f.zip
trace: names for PLT stubs and GOT slots; a call followed down; the vDSO is run through
For a disassembly that follows a call into libc. A stub is open@plt and a slot open@got, from the relocations (libc's own, IFUNC and nameless, by the function they resolve to); telescope.got says what a slot holds and whether it is still lazy. A library function's entry is named even when its mapping was not known yet, by the alias the program imports. The chain holds through the stub's jump, the callee's first instruction, the syscall and the loader's resolver: ld.so's unwind section lacks the entry that ends it, which lost every frame there. A syscall is tied to its instruction's moment, and each frame's call is recorded with the row before it. Stepped by instruction, a call into the vDSO is one moment and its return the next: its clock loop, single-stepped, made three million moments of three reads. Co-Authored-By: Claude Fable 5.2 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'src/trace/Symbols.zig')
-rw-r--r--src/trace/Symbols.zig193
1 files changed, 188 insertions, 5 deletions
diff --git a/src/trace/Symbols.zig b/src/trace/Symbols.zig
index 3ebd418..1459503 100644
--- a/src/trace/Symbols.zig
+++ b/src/trace/Symbols.zig
@@ -19,6 +19,9 @@ row: struct { start: u64 = 0, len: u64 = 0, line: ?Line = null } = .{},
/// Names are then shown and found so, without their parameters:
/// "v8::internal::Heap::CollectGarbage" for "_ZN2v88internal4Heap14Coll...".
demangle: ?*const fn (name: []const u8, buf: []u8) ?[]const u8 = null,
+/// The names the modules' relocations import: what a caller calls a
+/// function that has several (`open`, not `__open64`).
+imported: std.StringHashMapUnmanaged(void) = .empty,
pub const Mapping = struct {
start: u64,
@@ -66,9 +69,14 @@ pub const Module = struct {
unwinds: [2]Dwarf.Unwind = undefined,
unwinds_len: u8 = 0,
unwinds_tried: bool = false,
+ /// .eh_frame with the zero entry that ends it, where the file has none (ld.so).
+ eh_frame: []u8 = &.{},
/// Each function's rows of it, decoded on first use, by its first
/// address in the file.
cfi: std.AutoHashMapUnmanaged(u64, struct { len: u64, rows: []Row }) = .empty,
+ /// The names made for it (`readPlt`'s), and its PLT's sections.
+ names: std.heap.ArenaAllocator.State = .{},
+ plts: [3]Plt = @splat(.{}),
/// The call frame information, prepared on first use.
fn unwindTables(m: *Module, gpa: std.mem.Allocator) []Dwarf.Unwind {
@@ -80,7 +88,16 @@ pub const Module = struct {
var u: Dwarf.Unwind = .initSection(id, s.vaddr, s.bytes);
u.prepare(gpa, 8, .little, true, false) catch {
u.deinit(gpa);
- continue;
+ // ld.so's .eh_frame ends without the zero entry the unwinder needs: given one.
+ if (id != .eh_frame) continue;
+ m.eh_frame = gpa.alloc(u8, s.bytes.len + 4) catch continue;
+ @memcpy(m.eh_frame[0..s.bytes.len], s.bytes);
+ @memset(m.eh_frame[s.bytes.len..], 0);
+ u = .initSection(id, s.vaddr, m.eh_frame);
+ u.prepare(gpa, 8, .little, true, false) catch {
+ u.deinit(gpa);
+ continue;
+ };
};
m.unwinds[m.unwinds_len] = u;
m.unwinds_len += 1;
@@ -88,9 +105,12 @@ pub const Module = struct {
return m.unwinds[0..m.unwinds_len];
}
+ /// A function's rows, where it begins (in the file) and how long it is.
+ const Rows = struct { start: u64, len: u64, rows: []const Row };
+
/// The function whose call frame information holds `pc`, an address in
- /// the file: where it begins (in the file) and its rows.
- fn rowsAt(m: *Module, gpa: std.mem.Allocator, pc: u64) ?struct { start: u64, len: u64, rows: []const Row } {
+ /// the file: by the unwind tables, else (a PLT entry) by its code.
+ fn rowsAt(m: *Module, gpa: std.mem.Allocator, pc: u64) ?Rows {
for (m.unwindTables(gpa)) |*u| {
const at = (u.lookupPc(pc, 8, .little) catch null) orelse continue;
const cie, const fde = u.getFde(at, .little) catch continue;
@@ -101,7 +121,29 @@ pub const Module = struct {
if (entry.value_ptr.rows.len == 0) return null;
return .{ .start = fde.pc_begin, .len = entry.value_ptr.len, .rows = entry.value_ptr.rows };
}
- return null;
+ return m.pltRows(gpa, pc);
+ }
+
+ /// A PLT entry's rows where the unwind tables have none (Zig's linker
+ /// writes none), from its code, as GNU ld's expression says them:
+ /// rsp + 8, and rsp + 16 after its push; the first entry's rsp + 16, and
+ /// rsp + 24 after its push.
+ fn pltRows(m: *Module, gpa: std.mem.Allocator, pc: u64) ?Rows {
+ const file = m.file orelse return null;
+ const p = for (m.plts) |p| {
+ if (pc >= p.addr and pc - p.addr < p.size) break p;
+ } else return null;
+ const entry = p.addr + (pc - p.addr) / p.entsize * p.entsize;
+ const cached = m.cfi.getOrPut(gpa, entry) catch return null;
+ if (!cached.found_existing) {
+ const s = stub(file.mapped_file[p.offset + (entry - p.addr) ..][0..@min(p.entsize, p.addr + p.size - entry)], entry);
+ const returns: [saved_registers.len]i8 = .{ 0, 0, 0, 0, 0, 0, -1 };
+ const cfa: i32 = if (s.first) 16 else 8;
+ const rows = [_]Row{ .{ .offset = 0, .cfa = cfa, .cfa_reg = 7, .saved = returns }, .{ .offset = s.pushed orelse 0, .cfa = cfa + 8, .cfa_reg = 7, .saved = returns } };
+ cached.value_ptr.* = .{ .len = p.entsize, .rows = gpa.dupe(Row, rows[0 .. @as(usize, 1) + @intFromBool(s.pushed != null)]) catch &.{} };
+ }
+ if (cached.value_ptr.rows.len == 0) return null;
+ return .{ .start = entry, .len = cached.value_ptr.len, .rows = cached.value_ptr.rows };
}
/// The line tables, opened on first use. Null without debug info.
@@ -154,10 +196,13 @@ pub fn deinit(s: *Symbols) void {
var decoded = m.cfi.valueIterator();
while (decoded.next()) |f| s.gpa.free(f.rows);
m.cfi.deinit(s.gpa);
+ m.names.promote(s.gpa).deinit();
+ s.gpa.free(m.eh_frame);
s.gpa.free(m.symbols);
s.gpa.free(m.path);
}
s.modules.deinit(s.gpa);
+ s.imported.deinit(s.gpa);
s.free(s.maps);
}
@@ -249,6 +294,23 @@ fn load(s: *Symbols, path: []const u8) !void {
error.OutOfMemory => |e| return e,
else => &.{},
};
+ // And its PLT's stubs and GOT's slots, named.
+ var names = m.names.promote(s.gpa);
+ defer m.names = names.state;
+ const made = readPlt(s.gpa, names.allocator(), f.mapped_file, m.symbols, &s.imported, &m.plts) catch |err| switch (err) {
+ error.OutOfMemory => |e| return e,
+ else => &.{},
+ };
+ if (made.len > 0) {
+ const before = m.symbols.len;
+ m.symbols = try s.gpa.realloc(m.symbols, before + made.len);
+ @memcpy(m.symbols[before..], made);
+ std.mem.sortUnstable(Symbol, m.symbols, {}, struct {
+ fn lessThan(_: void, a: Symbol, b: Symbol) bool {
+ return a.addr < b.addr;
+ }
+ }.lessThan);
+ }
if (firstLoad(f.mapped_file)) |first| {
m.entry = first.entry;
// Where the file's first segment landed tells where all of it did.
@@ -344,11 +406,132 @@ pub fn symbolAt(s: *Symbols, addr: u64) ?Symbol {
var i = after;
while (i > 0 and after - i < 8) : (i -= 1) {
const sym = m.symbols[i - 1];
- if (pc - sym.addr < @max(sym.size, 1)) return .{ .name = sym.name, .addr = sym.addr + m.bias, .size = sym.size };
+ if (pc - sym.addr >= @max(sym.size, 1)) continue;
+ // Of the names one place has, the one a module calls it by.
+ var j = i;
+ const name = while (j > 0 and m.symbols[j - 1].addr == sym.addr) : (j -= 1) {
+ if (s.imported.contains(m.symbols[j - 1].name)) break m.symbols[j - 1].name;
+ } else sym.name;
+ return .{ .name = name, .addr = sym.addr + m.bias, .size = sym.size };
}
return null;
}
+/// A PLT's section, as addresses in the file: `entsize` bytes an entry.
+const Plt = struct { addr: u64 = 0, offset: u64 = 0, size: u64 = 0, entsize: u64 = 16 };
+
+/// The PLT's stubs and the GOT's slots of a file, as symbols named for the
+/// function they lead to, from its relocations and dynamic symbols:
+/// `open@plt`, `open@got`; an IFUNC's (an IRELATIVE relocation, which
+/// names none) by the function its resolver is (`strlen@plt`). A stub is
+/// known by the slot its `jmp` reads, or, in a PLT whose stubs jump
+/// elsewhere (`.plt.sec`'s other half), by the relocation it pushes. Puts
+/// the names the relocations import in `imported`, and the PLT's sections
+/// in `plts`; the names are `arena`'s.
+fn readPlt(gpa: std.mem.Allocator, arena: std.mem.Allocator, bytes: []const u8, symbols: []const Symbol, imported: *std.StringHashMapUnmanaged(void), plts: *[3]Plt) ![]Symbol {
+ var r: std.Io.Reader = .fixed(bytes);
+ const header = try elf.Header.read(&r);
+ if (!header.is_64 or header.endian != .little) return &.{};
+ const names_at = header.shoff + @as(u64, header.shstrndx) * header.shentsize;
+ if (names_at + @sizeOf(elf.Elf64_Shdr) > bytes.len) return error.TruncatedElfFile;
+ const names_sh = std.mem.bytesToValue(elf.Elf64_Shdr, bytes[names_at..][0..@sizeOf(elf.Elf64_Shdr)]);
+ if (names_sh.sh_offset + names_sh.sh_size > bytes.len) return error.TruncatedElfFile;
+ const section_names = bytes[names_sh.sh_offset..][0..names_sh.sh_size];
+ var relas: [2]?elf.Elf64_Shdr = @splat(null);
+ var dynsym: ?elf.Elf64_Shdr = null;
+ var it = header.iterateSectionHeadersBuffer(bytes);
+ while (try it.next()) |sh| {
+ if (sh.sh_name >= section_names.len or sh.sh_offset + sh.sh_size > bytes.len) continue;
+ const name = std.mem.sliceTo(section_names[sh.sh_name..], 0);
+ if (sh.sh_type == elf.SHT_DYNSYM) dynsym = sh;
+ if (sh.sh_type == elf.SHT_RELA) for ([_][]const u8{ ".rela.plt", ".rela.dyn" }, &relas) |want, *slot| {
+ if (std.mem.eql(u8, name, want)) slot.* = sh;
+ };
+ for ([_][]const u8{ ".plt", ".plt.sec", ".plt.got" }, plts) |want, *p| {
+ if (std.mem.eql(u8, name, want) and sh.sh_type == elf.SHT_PROGBITS) p.* = .{ .addr = sh.sh_addr, .offset = sh.sh_offset, .size = sh.sh_size, .entsize = if (sh.sh_entsize != 0) sh.sh_entsize else 16 };
+ }
+ }
+ const syms_sh = dynsym orelse return &.{};
+ const strs_at = header.shoff + @as(u64, syms_sh.sh_link) * header.shentsize;
+ if (strs_at + @sizeOf(elf.Elf64_Shdr) > bytes.len) return error.TruncatedElfFile;
+ const strs_sh = std.mem.bytesToValue(elf.Elf64_Shdr, bytes[strs_at..][0..@sizeOf(elf.Elf64_Shdr)]);
+ if (strs_sh.sh_offset + strs_sh.sh_size > bytes.len) return error.TruncatedElfFile;
+ const strs = bytes[strs_sh.sh_offset..][0..strs_sh.sh_size];
+ const syms = std.mem.bytesAsSlice(elf.Elf64.Sym, bytes[syms_sh.sh_offset..][0 .. syms_sh.sh_size / @sizeOf(elf.Elf64.Sym) * @sizeOf(elf.Elf64.Sym)]);
+
+ var out: std.ArrayList(Symbol) = .empty;
+ // The function each GOT slot leads to, and each of .rela.plt's in order (what a lazy stub pushes).
+ var slots: std.AutoHashMapUnmanaged(u64, []const u8) = .empty;
+ defer slots.deinit(gpa);
+ var pushed: std.ArrayList(?[]const u8) = .empty;
+ defer pushed.deinit(gpa);
+ for (relas, 0..) |rela, which| {
+ const sh = rela orelse continue;
+ for (std.mem.bytesAsSlice(elf.Elf64_Rela, bytes[sh.sh_offset..][0 .. sh.sh_size / @sizeOf(elf.Elf64_Rela) * @sizeOf(elf.Elf64_Rela)])) |rel| {
+ const R = elf.R_X86_64;
+ const kind = std.enums.fromInt(R, rel.r_type()) orelse .NONE;
+ const name: ?[]const u8 = switch (kind) {
+ .JUMP_SLOT, .GLOB_DAT => if (rel.r_sym() < syms.len and syms[rel.r_sym()].name < strs.len) std.mem.sliceTo(strs[syms[rel.r_sym()].name..], 0) else null,
+ .IRELATIVE => for (symbols) |sym| {
+ if (sym.addr == @as(u64, @bitCast(rel.r_addend))) break sym.name;
+ } else null,
+ else => null,
+ };
+ if (which == 0) try pushed.append(gpa, name);
+ const n = name orelse continue;
+ if (n.len == 0) continue;
+ if (kind != .IRELATIVE) try imported.put(gpa, n, {});
+ try slots.put(gpa, rel.r_offset, n);
+ try out.append(arena, .{ .name = try std.fmt.allocPrint(arena, "{s}@got", .{n}), .addr = rel.r_offset, .size = 8 });
+ }
+ }
+ for (plts) |p| {
+ var entry = p.addr;
+ while (entry + p.entsize <= p.addr + p.size) : (entry += p.entsize) {
+ const s = stub(bytes[p.offset + (entry - p.addr) ..][0..p.entsize], entry);
+ if (s.first) continue;
+ const n = (if (s.slot) |slot| slots.get(slot) else null) orelse (if (s.index) |i| if (i < pushed.items.len) pushed.items[i] else null else null) orelse continue;
+ try out.append(arena, .{ .name = try std.fmt.allocPrint(arena, "{s}@plt", .{n}), .addr = entry, .size = p.entsize });
+ }
+ }
+ return out.items;
+}
+
+/// A PLT entry, decoded: the GOT slot its `jmp` reads; for lazy binding,
+/// the relocation it pushes and where its push ends; whether it is the
+/// PLT's first entry, which pushes the GOT's second word instead.
+const Stub = struct { slot: ?u64 = null, index: ?u32 = null, pushed: ?u32 = null, first: bool = false };
+
+fn stub(code: []const u8, addr: u64) Stub {
+ var s: Stub = .{};
+ var i: usize = 0;
+ while (i < code.len) {
+ const rest = code[i..];
+ if (std.mem.startsWith(u8, rest, &.{ 0xf3, 0x0f, 0x1e, 0xfa })) {
+ i += 4; // endbr64
+ } else if (rest[0] == 0xf2) {
+ i += 1; // bnd
+ } else if (rest.len >= 6 and rest[0] == 0xff and (rest[1] == 0x25 or rest[1] == 0x35)) {
+ // jmp or push [rip + disp32]
+ const at = addr +% (i + 6) +% @as(u64, @bitCast(@as(i64, std.mem.readInt(i32, rest[2..6], .little))));
+ if (rest[1] == 0x25) {
+ if (s.slot == null) s.slot = at;
+ } else {
+ s.first = true;
+ s.pushed = @intCast(i + 6);
+ }
+ i += 6;
+ } else if (rest.len >= 5 and rest[0] == 0x68) {
+ s.index = std.mem.readInt(u32, rest[1..5], .little);
+ s.pushed = @intCast(i + 5);
+ i += 5;
+ } else if (rest.len >= 5 and rest[0] == 0xe9) {
+ i += 5; // jmp rel32
+ } else break;
+ }
+ return s;
+}
+
/// A symbol by name: the executable's first, then the libraries'. As the
/// linker has it, else (with `demangle`) as the source does.
pub fn find(s: *Symbols, name: []const u8) ?Symbol {