summaryrefslogtreecommitdiff
path: root/src/trace/telescope.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-11 10:38:30 -0300
committerGabriel Schneider <[email protected]>2026-11-11 10:38:37 -0300
commit6a7a87b8ecb7902de5640cad00028997825024d2 (patch)
tree9e76e47c769d62f0a1affa563b9fba9849e2ab5d /src/trace/telescope.zig
parent390872b7bb9cdcf3e8095442af88af0dfcb40602 (diff)
downloadcomputeranim-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/telescope.zig')
-rw-r--r--src/trace/telescope.zig114
1 files changed, 114 insertions, 0 deletions
diff --git a/src/trace/telescope.zig b/src/trace/telescope.zig
index 6ab2929..006bb22 100644
--- a/src/trace/telescope.zig
+++ b/src/trace/telescope.zig
@@ -293,6 +293,72 @@ pub fn function(m: Moment, pc: u64) ?Function {
return .{ .start = start, .len = len, .base = t[4], .rows = t[7..][0..rows], .locals = t[7 + rows ..] };
}
+/// A basic block of a function: where it is, how it ends
+/// (`Debugger.End`), and its edges.
+pub const Block = struct {
+ start: u64,
+ len: u64,
+ end: Debugger.End,
+ /// Where it goes: a jump's target, a conditional jump's when taken, a
+ /// tail call's or a call's that does not return; null for none, or
+ /// where it is not known (`indirect`).
+ to: ?u64,
+ /// The block it falls into, after it: `fall`'s, and a conditional
+ /// jump's when not taken; null otherwise.
+ falls: ?u64,
+};
+
+/// A function as its blocks, from the recording (`Debugger.emitBlocks`):
+/// its bounds, its blocks in address order (`blocks`, as many as `out`
+/// holds of `count`), the one that holds the pc, and whether every
+/// instruction's text is recorded (`instruction`; false past
+/// `Debugger.function_text`, the blocks recorded without it).
+pub const Graph = struct { start: u64, len: u64, blocks: []Block, count: usize, here: ?usize, text: bool };
+
+/// The blocks of the function that holds `pc`; null where the recording
+/// has none (no stop was ever in it).
+pub fn blocks(m: Moment, pc: u64, out: []Block) ?Graph {
+ const found = m.trace.stringBelow(event.blocksId(pc)) orelse return null;
+ if (found.id < event.blocksId(0)) return null;
+ const start = found.id - event.blocksId(0);
+ const t = found.text;
+ if (t.len < 5) return null;
+ const len = std.mem.readInt(u32, t[0..4], .little);
+ if (pc - start >= len) return null;
+ const size = @sizeOf(Debugger.Block);
+ const count = (t.len - 5) / size;
+ var g: Graph = .{ .start = start, .len = len, .blocks = out[0..@min(out.len, count)], .count = count, .here = null, .text = t[4] != 0 };
+ for (0..count) |i| {
+ const b = std.mem.bytesToValue(Debugger.Block, t[5 + i * size ..][0..size]);
+ const at = start + b.offset;
+ if (pc -% at < b.len) g.here = i;
+ if (i >= out.len) continue;
+ const to: ?u64 = switch (b.end) {
+ .jump, .branch, .tail, .noreturn => if (b.to == Debugger.no_target) null else start +% @as(u64, @bitCast(@as(i64, b.to))),
+ else => null,
+ };
+ out[i] = .{ .start = at, .len = b.len, .end = b.end, .to = to, .falls = if (b.end == .fall or b.end == .branch) at + b.len else null };
+ }
+ return g;
+}
+
+/// ASan's shadow byte of `addr` at a moment (`ztrace record --asan`): where
+/// it is, and what it holds where the recording has it: 0 all of its 8
+/// bytes addressable, 1 to 7 that many first ones, else why none is (f1 a
+/// stack frame's left redzone, f2 between its variables, f3 its right, f5
+/// a frame returned from, f8 a scope left, fa a heap block's redzone, fd
+/// freed). Null for a recording without the shadow.
+pub fn shadow(m: Moment, addr: u64) !?struct { addr: u64, value: ?u8 } {
+ const text = m.trace.strings.get(Debugger.asan_id) orelse return null;
+ if (text.len != @sizeOf(Debugger.Asan)) return null;
+ const asan = std.mem.bytesToValue(Debugger.Asan, text[0..@sizeOf(Debugger.Asan)]);
+ const at = (addr >> @intCast(asan.scale)) + asan.offset;
+ var byte: [1]u8 = undefined;
+ var known: [1]bool = undefined;
+ try m.read(at, &byte, &known);
+ return .{ .addr = at, .value = if (known[0]) byte[0] else null };
+}
+
/// A GOT slot at a moment: what it holds, and whether that is still the way
/// back into the PLT (`lazy`: the next call through it runs the loader's
/// resolver, which binds it) rather than the function. Null where the
@@ -533,3 +599,51 @@ test "frames walked by their call frame information; each stack word's role" {
var two: [2]u64 = undefined;
try std.testing.expectEqual(@as(u64, 0x400050), (try backtrace(m, &entry, &two))[1]);
}
+
+test "a function's blocks: their edges, the one that holds the pc, and whether their text is recorded" {
+ const gpa = std.testing.allocator;
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ var dir_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
+ const dir = dir_buf[0..try tmp.dir.realPath(std.testing.io, &dir_buf)];
+ const path = try std.fs.path.join(gpa, &.{ dir, "t.ztrace" });
+ defer gpa.free(path);
+
+ var rec = try store.Recorder.create(gpa, std.testing.io, path);
+ // A function at 400000, 0x40 long, past the text budget (its byte 0): a
+ // test that branches over a loop, the loop, a call through a register
+ // that never returns, and a tail call.
+ const B = Debugger.Block;
+ const blocks_ = [_]B{
+ .{ .offset = 0, .len = 8, .to = 0x20, .end = .branch },
+ .{ .offset = 8, .len = 0x10, .to = 8, .end = .branch },
+ .{ .offset = 0x18, .len = 8, .to = Debugger.no_target, .end = .noreturn },
+ .{ .offset = 0x20, .len = 0x20, .to = 0x1000, .end = .tail },
+ };
+ try rec.emit(.{ .kind = .string, .a = .{ event.blocksId(0x400000), 0, 0, 0, 0, 0 } }, "\x40\x00\x00\x00\x00" ++ std.mem.asBytes(&blocks_));
+ try rec.emit(.{ .kind = .mark, .tid = 1 }, "");
+ try rec.close();
+
+ var trace = try store.Trace.open(gpa, std.testing.io, path);
+ defer trace.close();
+ const m = try trace.moment(0);
+ var out: [3]Block = undefined;
+ const g = blocks(m, 0x400024, &out).?;
+ try std.testing.expectEqual(@as(u64, 0x400000), g.start);
+ try std.testing.expectEqual(@as(u64, 0x40), g.len);
+ try std.testing.expect(!g.text);
+ // Four blocks, three of them given; the pc in the last.
+ try std.testing.expectEqual(@as(usize, 4), g.count);
+ try std.testing.expectEqual(@as(usize, 3), g.blocks.len);
+ try std.testing.expectEqual(@as(?usize, 3), g.here);
+ try std.testing.expectEqualSlices(Block, &.{
+ .{ .start = 0x400000, .len = 8, .end = .branch, .to = 0x400020, .falls = 0x400008 },
+ .{ .start = 0x400008, .len = 0x10, .end = .branch, .to = 0x400008, .falls = 0x400018 },
+ .{ .start = 0x400018, .len = 8, .end = .noreturn, .to = null, .falls = null },
+ }, g.blocks);
+ var all: [4]Block = undefined;
+ try std.testing.expectEqual(Block{ .start = 0x400020, .len = 0x20, .end = .tail, .to = 0x401000, .falls = null }, blocks(m, 0x400020, &all).?.blocks[3]);
+ // Outside it, nothing.
+ try std.testing.expect(blocks(m, 0x400040, &all) == null);
+ try std.testing.expect(blocks(m, 0x3fffff, &all) == null);
+}