diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-11 10:38:30 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-11 10:38:37 -0300 |
| commit | 6a7a87b8ecb7902de5640cad00028997825024d2 (patch) | |
| tree | 9e76e47c769d62f0a1affa563b9fba9849e2ab5d /src/trace/Debugger.zig | |
| parent | 390872b7bb9cdcf3e8095442af88af0dfcb40602 (diff) | |
| download | computeranim-6a7a87b8ecb7902de5640cad00028997825024d2.tar.gz computeranim-6a7a87b8ecb7902de5640cad00028997825024d2.zip | |
trace: a function's basic blocks; ASan's shadow memory
For a graph of a function's blocks: at the first stop inside it a
function's blocks are recorded once (bounds, how each ends, where its
edges go), with every instruction's text up to 2048 of them;
telescope.blocks reads them, and a branch event ties a run to the edge
it took. Stripped libraries get blocks from their unwind bounds.
For a plain build seen against an ASan one: record --asan keeps the
shadow of every region it records, the offset found from the process;
telescope.shadow gives an address's shadow byte. The report functions
are named and the chain holds from inside the report to main. Tested on
an overflowing target built plain, with gcc's ASan and with clang's.
Co-Authored-By: Claude Fable 5.2 <[email protected]>
Claude-Session: https://claude.ai/code/session_016Y9MNCKgYCGiANnEwcEQxa
Diffstat (limited to 'src/trace/Debugger.zig')
| -rw-r--r-- | src/trace/Debugger.zig | 171 |
1 files changed, 163 insertions, 8 deletions
diff --git a/src/trace/Debugger.zig b/src/trace/Debugger.zig index 971b50b..d312dec 100644 --- a/src/trace/Debugger.zig +++ b/src/trace/Debugger.zig @@ -66,6 +66,11 @@ allocations: std.ArrayList(Watch) = .empty, /// The most read of them at a stop, in bytes: a stop's cost must not grow /// with the target's heap. allocation_watch: usize = 256 << 10, +/// ASan's shadow memory, recorded beside every region recorded (`--asan`): +/// its byte for each 8 bytes, at `(addr >> 3) + asan_shadow`. The offset +/// is the runtime's, found at the first stop after it set it. +asan: bool = false, +asan_shadow: ?u64 = null, /// glibc's heap, recorded at every stop as `heap.zig` reads it (`--heap`): null for not at all. heap: ?@import("heap.zig").Watch = null, breakpoints: std.ArrayList(Breakpoint) = .empty, @@ -87,6 +92,9 @@ written: [2]Touch = undefined, written_count: usize = 0, /// The instructions above and below the pc whose text a stop records. disasm_around: usize = 8, +/// The most instructions of a function recorded whole with its blocks +/// (`emitBlocks`): a larger one's blocks are recorded without their text. +function_text: usize = 2048, /// Each function met, as where its instructions begin (`instructions`). functions: std.AutoHashMapUnmanaged(u64, []const u32) = .empty, /// How far a stop follows pointers, from each register and from each of @@ -146,8 +154,9 @@ pub const Breakpoint = struct { id: u32, addr: u64, saved: u8, hook: ?Hook }; pub const Insn = struct { len: u8, text: []const u8, touches: []const Touch = &.{}, branch: Branch = .{} }; /// Where a call, a jump or a return goes. `kind`: 0 not one, 1 call, 2 /// jump, 3 return. With `indirect` the target is read from the -/// instruction's memory operand; a return's is on the stack. -pub const Branch = extern struct { target: u64 = 0, kind: u8 = 0, taken: u8 = 1, indirect: u8 = 0 }; +/// instruction's memory operand; a return's is on the stack. `conditional`: +/// a jump on a condition. +pub const Branch = extern struct { target: u64 = 0, kind: u8 = 0, taken: u8 = 1, indirect: u8 = 0, conditional: u8 = 0 }; /// Memory an instruction touches: `how` is 1 for a read, 2 a write, 3 both. pub const Touch = extern struct { addr: u64, size: u8, how: u8 }; pub const Watch = struct { addr: u64, len: usize }; @@ -506,6 +515,7 @@ fn report(d: *Debugger, stop: Stop) !Stop { if (d.sink == null) return stop; if (!d.done) { try d.emitLine(); + if (d.asan and d.asan_shadow == null) try d.findShadow(); // With the 128 bytes under the stack pointer: the red zone, a leaf's locals. if (d.stack_watch > 0) try d.snapshot(d.regs.rsp -| 128, d.stack_watch + 128); for (d.watches.items) |w| try d.snapshot(w.addr, w.len); @@ -564,11 +574,13 @@ fn emitCode(d: *Debugger) !void { } } // The instructions round the pc, in address order. Inside a function - // they are known both ways, the function decoded once from its start; - // elsewhere (no symbol: stripped code, a JIT's) only from the pc on. + // they are known both ways, the function decoded once from its start, + // and its blocks are recorded; elsewhere (no bounds: a JIT's code) only + // from the pc on. const around = d.disasm_around; - if (d.syms.symbolAt(d.regs.rip)) |sym| if (sym.size > 0 and sym.size <= 1 << 16) { + if (d.bounds(d.regs.rip)) |sym| if (sym.size > 0 and sym.size <= 1 << 20) { const starts = try d.instructions(sym, insnAt); + try d.emitBlocks(insnAt, sym, starts); const here: u32 = @intCast(d.regs.rip - sym.addr); const at = std.sort.binarySearch(u32, starts, here, struct { fn order(want: u32, have: u32) std.math.Order { @@ -642,6 +654,124 @@ fn instructions(d: *Debugger, sym: Symbols.Symbol, insnAt: @typeInfo(@TypeOf(d.d return entry.value_ptr.*; } +/// Where the function that holds `addr` begins and how long it is: by its +/// symbol, else by its call frame information (a stripped library's). +fn bounds(d: *Debugger, addr: u64) ?Symbols.Symbol { + if (d.syms.symbolAt(addr)) |sym| if (sym.size > 0) return sym; + const f = d.syms.functionAt(addr) orelse return null; + return .{ .name = "", .addr = f.start, .size = f.len }; +} + +/// How a basic block ends. +pub const End = enum(u8) { + /// Into the block after it, which something jumps to. + fall, + /// An unconditional jump in the function, to `to`. + jump, + /// A conditional jump: to `to` when taken, else into the block after it. + branch, + ret, + /// A jump through a register or memory, to where is not known. + indirect, + /// A jump out of the function, to `to`: a tail call. + tail, + /// A call that does not return, to `to` (`no_target`: through a + /// register or memory): the function's last instruction, or a call of + /// one that never returns (`noreturn_names`). + noreturn, +}; + +/// A basic block as `emitBlocks` records it: `offset` bytes into its +/// function, `len` long, how it ends, and where to (`to`, from the +/// function's start). +pub const Block = extern struct { offset: u32, len: u32, to: i32 = 0, end: End, pad: [3]u8 = @splat(0) }; +pub const no_target = std.math.minInt(i32); + +/// Functions that never return: a call of one ends its block. +const noreturn_names = [_][]const u8{ "abort", "exit", "_exit", "_Exit", "__stack_chk_fail", "__assert_fail", "__fortify_fail", "__chk_fail", "longjmp", "siglongjmp", "__longjmp_chk", "pthread_exit", "__cxa_throw", "__cxa_rethrow", "_Unwind_Resume" }; + +/// A function's basic blocks, recorded once as a string (`event.blocksId` +/// of where it begins): its length (4 bytes), a byte that is 1 when every +/// instruction of it is recorded too (`function_text` of them at most: +/// strings by `event.codeId`, as `emitInstruction` writes them; and the +/// names of where its calls and jumps out of it go), then its +/// blocks (`Block`). Decoded from its instructions: a block begins at the +/// function's start, at each jump's target in it, and after each jump, +/// return and call that does not return; a call that returns ends none. +fn emitBlocks(d: *Debugger, insnAt: @typeInfo(@TypeOf(d.disasm)).optional.child, sym: Symbols.Symbol, starts: []const u32) !void { + if ((try d.described.getOrPut(d.gpa, event.blocksId(sym.addr))).found_existing) return; + const code = try d.gpa.alloc(u8, sym.size); + defer d.gpa.free(code); + const n = d.read(sym.addr, code); + const branches = try d.gpa.alloc(Branch, starts.len); + defer d.gpa.free(branches); + // By instruction: the ones a block begins at, and the calls that do not return. + var leaders = try std.DynamicBitSetUnmanaged.initEmpty(d.gpa, starts.len + 1); + defer leaders.deinit(d.gpa); + var stops = try std.DynamicBitSetUnmanaged.initEmpty(d.gpa, starts.len); + defer stops.deinit(d.gpa); + leaders.set(0); + var text: [192]u8 = undefined; + for (starts, branches, 0..) |off, *b, k| { + b.* = if (off < n) if (insnAt(code[off..n], sym.addr + off, &text, null, &.{})) |insn| insn.branch else .{} else .{}; + if (b.kind == 1 and noReturn(d, b.*, k + 1 == starts.len)) stops.set(k); + if (b.kind == 2 or b.kind == 3 or stops.isSet(k)) leaders.set(k + 1); + if (b.kind == 2 and b.indirect == 0 and b.target -% sym.addr < sym.size) { + if (std.sort.binarySearch(u32, starts, @as(u32, @intCast(b.target - sym.addr)), struct { + fn order(want: u32, have: u32) std.math.Order { + return std.math.order(want, have); + } + }.order)) |target| leaders.set(target); + } + } + var out: std.Io.Writer.Allocating = .init(d.gpa); + defer out.deinit(); + const w = &out.writer; + try w.writeInt(u32, @intCast(sym.size), .little); + try w.writeByte(@intFromBool(starts.len <= d.function_text)); + var first: usize = 0; + for (branches, 0..) |b, k| { + if (!leaders.isSet(k + 1) and k + 1 < starts.len) continue; + const end: u32 = if (k + 1 < starts.len) starts[k + 1] else @intCast(sym.size); + var block: Block = .{ .offset = starts[first], .len = end - starts[first], .end = .fall }; + const to = std.math.cast(i32, @as(i64, @bitCast(b.target -% sym.addr))); + switch (b.kind) { + 2 => if (b.indirect != 0 or b.target == 0 or to == null) { + block.end = .indirect; + } else { + block.to = to.?; + block.end = if (b.conditional != 0) .branch else if (b.target -% sym.addr < sym.size) .jump else .tail; + }, + 3 => block.end = .ret, + 1 => if (stops.isSet(k)) { + block.end = .noreturn; + block.to = if (b.indirect != 0 or b.target == 0) no_target else to orelse no_target; + }, + else => {}, + } + try w.writeAll(std.mem.asBytes(&block)); + first = k + 1; + } + // The text of each instruction, when there are few enough, and the + // name of each place its calls and its jumps out of it go. + if (starts.len <= d.function_text) for (starts, branches, 0..) |off, b, k| { + _ = try d.emitInstruction(insnAt, sym.addr + off, if (k > 0) @intCast(starts[k] - starts[k - 1]) else 0); + if ((b.kind == 1 or b.kind == 2) and b.indirect == 0 and b.target != 0 and b.target -% sym.addr >= sym.size) try d.nameAddress(b.target); + }; + try d.emit(.{ .kind = .string, .a = .{ event.blocksId(sym.addr), 0, 0, 0, 0, 0 } }, out.written()); +} + +/// Whether a call never returns: it is its function's last instruction, +/// or its callee is one of `noreturn_names` (through its PLT stub too). +fn noReturn(d: *Debugger, b: Branch, last: bool) bool { + if (last) return true; + if (b.indirect != 0 or b.target == 0) return false; + const callee = (d.syms.symbolAt(b.target) orelse return false).name; + const name = if (std.mem.endsWith(u8, callee, "@plt")) callee[0 .. callee.len - "@plt".len] else callee; + for (noreturn_names) |known| if (std.mem.eql(u8, known, name)) return true; + return false; +} + /// What a viewer follows from the registers and the top of the stack, as /// pwndbg's telescope does: recorded here, while the memory is there to read. fn emitTelescope(d: *Debugger) !void { @@ -670,8 +800,7 @@ fn emitTelescope(d: *Debugger) !void { fn emitCall(d: *Debugger, ret: u64) !void { const insnAt = d.disasm orelse return; if ((try d.described.getOrPut(d.gpa, event.codeId(ret))).found_existing) return; - // Where its function begins: its symbol's, else its call frame information's (a stripped library's). - const sym = d.syms.symbolAt(ret) orelse if (d.syms.functionAt(ret -% 1)) |f| Symbols.Symbol{ .name = "", .addr = f.start, .size = f.len } else return; + const sym = d.bounds(ret -% 1) orelse return; if (sym.size == 0 or sym.size > 1 << 16 or ret == sym.addr) return; const starts = try d.instructions(sym, insnAt); const k = std.sort.binarySearch(u32, starts, @as(u32, @intCast(ret - sym.addr)), struct { @@ -838,9 +967,35 @@ pub fn snapshot(d: *Debugger, addr: u64, len: usize) !void { _ = try d.snap(addr, len); } +/// Where ASan's shadow is (`--asan`), recorded once as the string +/// `asan_id`: a byte of shadow for 2^`scale` bytes of memory, at +/// `(addr >> scale) + offset`. +pub const Asan = extern struct { offset: u64, scale: u64 }; +pub const asan_id = event.stringId("asan shadow"); + +/// ASan's shadow offset, as its runtime has it: the value it exports in +/// `__asan_shadow_memory_dynamic_address`, set at its start (0x7fff8000 on +/// x86-64 Linux), and a mapping there (its low shadow). Its scale is 3 on +/// x86-64 (the runtime keeps it in no variable). +fn findShadow(d: *Debugger) !void { + const sym = d.syms.find("__asan_shadow_memory_dynamic_address") orelse return; + var word: [8]u8 = undefined; + if (d.read(sym.addr, &word) != 8) return; + const offset = std.mem.readInt(u64, &word, .little); + if (offset == 0 or d.syms.mappingAt(offset) == null) return; + d.asan_shadow = offset; + try d.emit(.{ .kind = .string, .a = .{ asan_id, 0, 0, 0, 0, 0 } }, std.mem.asBytes(&Asan{ .offset = offset, .scale = 3 })); +} + /// `snapshot`, returning what was read: from `addr` rounded down to a word, -/// valid until the next read. +/// valid until the next read. With ASan's shadow, its bytes for the region +/// are sent first. fn snap(d: *Debugger, addr: u64, len: usize) ![]const u8 { + if (d.asan_shadow) |offset| _ = try d.snapOnly((addr >> 3) + offset, ((addr + len + 7) >> 3) - (addr >> 3)); + return d.snapOnly(addr, len); +} + +fn snapOnly(d: *Debugger, addr: u64, len: usize) ![]const u8 { const start = addr & ~@as(u64, 7); try d.scratch.resize(d.gpa, std.mem.alignForward(usize, len + (addr - start), 8)); const bytes = d.scratch.items[0 .. d.read(start, d.scratch.items) & ~@as(usize, 7)]; |
