//! The state column (design/README.md, "3. Panels"): `registers`, all //! seventeen, each followed as far as it points; `stack`, the words from //! rsp with the frames they belong to as `call` spans down its right edge //! and the registers that point at a word as `pin`s in its lane; and //! `backtrace`, the call chain as rows, a panel of its own only in the //! `none` split. Ink says what a thing is, paper what happened to it. //! Reads `Moment.regs`, `Moment.read`, the mappings (through //! `zt.telescope`), and the names the debugger recorded. const std = @import("std"); const sk = @import("sketch"); const anim = @import("anim"); const zt = @import("ztrace"); const ui = @import("ui.zig"); const rows = @import("rows.zig"); const cursors = @import("cursor.zig"); const Recording = @import("Recording.zig"); const syscalls = @import("syscalls.zig"); const ties = @import("ties.zig"); const Stage = @import("stage.zig").Stage; const theme = ui.theme; const time = theme.time; const Rect = ui.Rect; const t = theme.color.text; const m = theme.metric.context; pub const ink = rows.ink; pub const regionOf = rows.regionOf; /// The registers' tag: the legend of what an address's ink says, always on screen, as pwndbg's is. pub const legend = blk: { const c = theme.color.region; break :blk [_]ui.Legend{ .{ .text = "stack", .ink = ui.rgb(c.stack) }, .{ .text = "heap", .ink = ui.rgb(c.heap) }, .{ .text = "code", .ink = ui.rgb(c.code_) }, .{ .text = "data", .ink = ui.rgb(c.data) }, .{ .text = "rwx", .ink = ui.rgb(c.data), .under = true }, .{ .text = "read-only", .ink = ui.rgb(c.rodata) }, }; }; /// A panel's `Ui`, moved to where the stage has its box now. pub fn at(f: *sk.Frame, placed: anim.Placed, box: Rect) ui.Ui { return (ui.Ui{ .f = f, .at = placed }).moved(box.x, box.y); } pub fn veiled(u: ui.Ui, box: Rect, amount: f32) void { // Staging: what cannot be read at a sprint is dimmed, not removed. u.veil(.{ .x = theme.stroke.rule, .y = m.tag, .w = box.w - 2 * theme.stroke.rule, .h = box.h - m.tag - theme.stroke.rule }, amount); } /// The rows a panel `box` shows: while a relayout moves it, one more, cut by its edge. pub fn rowsOf(box: Rect) usize { return @intFromFloat(@max(@ceil((box.h - m.tag - 2 * m.pad) / m.row), 0)); } pub fn clipBody(u: ui.Ui, box: Rect) void { u.clip(.{ .x = theme.stroke.rule, .y = m.tag + m.pad - 1, .w = box.w - 2 * theme.stroke.rule, .h = box.h - m.tag - 2 * m.pad + 2 }); } pub const Registers = struct { cursor: cursors.Cursor, stage: *const Stage, /// A step that makes a system call frames, as read, the registers /// that carry it, one at a time; and rax is struck when it returns. syscalls: bool = false, /// No strikes: for a program whose instrumentation uses the registers /// between any two lines, so that nearly all of them change at every one. quiet: bool = false, focus: bool = false, const Shown = struct { regs: zt.Regs, moment: Recording.Moment }; pub fn draw(r: *const Registers, f: *sk.Frame, placed: anim.Placed) void { const box = r.stage.box(placed, .registers); const u = at(f, placed, box); const now = r.cursor.now(placed); const rec = r.cursor.rec; var is: Shown = .{ .regs = (now.moment().regs(rec.tid) catch null) orelse zt.Regs{}, .moment = now.moment() }; var was: Shown = .{ .regs = (now.before().regs(rec.tid) catch null) orelse is.regs, .moment = now.before() }; if (r.syscalls) { // The registers as the newest call crossed with them: the // library's own use of them after it returns is not the story. if (syscalls.latest(rec, now.stops[0])) |n| is = shownAt(rec, rec.syscalls[n].enter) orelse is; if (syscalls.latest(rec, now.stops[1])) |n| was = shownAt(rec, rec.syscalls[n].enter) orelse was; } const body = u.panel(box.w, box.h, "registers", .{ .focus = r.focus, .legend = &legend }); // A link leaves from the panel's edge, not through a name. ties.anchor(u, .registers, .{ .x = 0, .y = 0, .w = box.w, .h = box.h }); clipBody(u, box); defer u.unclip(); const shown = @min(rowsOf(box), theme.metric.all_registers.len); // Overlapping action: of the registers one step wrote, each strikes 2 f after the one above it. for (theme.metric.all_registers[0..shown], 0..) |name, i| { const y = body.y + m.pad + @as(f32, @floatFromInt(i)) * m.row; if (std.mem.eql(u8, name, "rip")) { r.rip(u, now, y, box.w, is, was); continue; } r.row(u, now, is, was, name, y, box.w); } veiled(u, box, now.veil); } fn shownAt(rec: *const Recording, i: u64) ?Shown { const moment = rec.moment(i); return .{ .regs = (moment.regs(rec.tid) catch return null) orelse return null, .moment = moment }; } /// rip: where execution is, a current mark like the source's and the /// disassembly's; it moves with them, at the advance. fn rip(r: *const Registers, u: ui.Ui, now: cursors.Now, y: f32, w: f32, is: Shown, was: Shown) void { const rec = r.cursor.rec; const moment = now.marks[if (now.advancing() >= 0.5) 1 else 0]; const landed = now.landed(.cpu, 0); const flags = (if (landed) is else was).regs.eflags; // The flags a step changed are ticked, for three steps. const eflags_index = comptime index("eflags").?; // Until this step's change lands, the ticks are the last one's: no effect before its cause. const age = if (landed) now.registerAge(eflags_index) else now.registerAgeFrom(eflags_index, 1); var changed: u64 = 0; if (age) |a| changed = rec.register(now.stops[a], "eflags") ^ rec.register(now.stops[a + 1], "eflags"); const held = if (r.quiet) 0 else now.register(eflags_index, 0).level; rows.rip(u, y, w, rec.moment(moment), rec.register(moment, "rip"), flags, changed, held, 0); } fn row(r: *const Registers, u: ui.Ui, now: cursors.Now, is: Shown, was: Shown, name: []const u8, y: f32, w: f32) void { const i = index(name) orelse return; const value_now = is.regs.named(name) orelse return; const value_was = was.regs.named(name) orelse value_now; var marks: rows.Marks = .{}; var landed = now.landed(.cpu, 0); if (if (r.syscalls) syscalls.inStep(now) else null) |made| { const plan = syscalls.Plan.of(made); const is_rax = std.mem.eql(u8, name, "rax"); const carrier: ?usize = if (is_rax) 0 else for (syscalls.carried(made), 1..) |carried, k| { if (std.mem.eql(u8, carried, name)) break k; } else null; // What carries the call is framed as read, one register at a // time: they are what crosses the line. const framed = now.time - plan.registers - @as(f32, @floatFromInt(carrier orelse 0)) * time.flight.second; landed = framed >= 0; if (carrier != null) { marks.read = 0; marks.read_shows = @min(std.math.clamp(framed / time.read.in, 0, 1), now.reading(.cpu, 0)); } if (is_rax) { // rax: the call's number going in, the result coming back. const back = now.time - plan.returns; const result = back >= time.strike.in / 2.0; const value: u64 = if (result) value_now else if (landed) made.nr else value_was; if (back >= -time.strike.arm) { marks = .{ .first = now.heat(0, null, back) }; if (back >= 0 and now.walking()) marks.extend = back; } const hops = rows.reg(u, y, w, name, if (result) is.moment else was.moment, value, marks); return anchor(u, i, hops, y); } } else if (r.quiet) { // Unmarked: the values change as the mark moves on. landed = now.advancing() >= 0.5; } else { const age = now.registerAge(i); const delay = if (age == 0) ties.strikeDelay(now, i) else 0; landed = now.landed(.cpu, delay); marks.first = now.register(i, delay); // A register written: the rest of its chain is followed again. const since = now.since(.cpu, delay); if (age == 0 and now.walking() and since >= 0) marks.extend = since; } const hops = rows.reg(u, y, w, name, if (landed) is.moment else was.moment, if (landed) value_now else value_was, marks); anchor(u, i, hops, y); } fn anchor(u: ui.Ui, i: usize, hops: rows.Hops, y: f32) void { if (hops.n > 0) ties.anchor(u, .{ .register = i }, .{ .x = hops.x[0], .y = y, .w = hops.w[0], .h = m.row }); } }; /// A register's place in `Regs.names`. pub fn index(name: []const u8) ?usize { for (zt.Regs.names, 0..) |known, i| if (std.mem.eql(u8, known, name)) return i; return null; } /// One frame of the call chain, on the stack: its function's pc, and the /// slots that are the frame, from `lo` to `hi` (the last; null: its end is /// not known, past what the recording holds). pub const Frame = struct { pc: u64, lo: u64, hi: ?u64 }; /// The frames at moment `i`, newest first, with their extents, as the /// tracer reads them off the frame-pointer chain. pub fn frames(rec: *const Recording, i: u64, out: []Frame) []Frame { const moment = rec.moment(i); const regs = (moment.regs(rec.tid) catch return out[0..0]) orelse return out[0..0]; var buf: [24]zt.Debugger.Frame = undefined; const found = zt.telescope.frames(moment, ®s, buf[0..@min(buf.len, out.len)]) catch return out[0..0]; for (found, out[0..found.len]) |f, *o| o.* = .{ .pc = f.pc, .lo = f.low, .hi = if (f.high > f.low) f.high - 8 else null }; return out[0..found.len]; } /// A frame's name: its function's (no offset), or its module's and offset where there is no symbol. pub fn frameName(u: ui.Ui, rec: *const Recording, pc: u64) []const u8 { const name = rec.strings.get(pc) orelse return u.print("{x}", .{pc}); if (std.mem.indexOfScalar(u8, name, '!') != null) return ui.symbol(u, name); return name[0 .. std.mem.lastIndexOfScalar(u8, name, '+') orelse name.len]; } /// The registers (of the sixteen) that hold `addr` in `regs`. fn pointing(u: ui.Ui, regs: zt.Regs, addr: u64) []const []const u8 { var out: std.ArrayList([]const u8) = .empty; for (theme.metric.all_registers[0..16]) |name| { if (regs.named(name) == addr) out.append(u.f.scratch, name) catch break; } return out.items; } pub const Stack = struct { cursor: cursors.Cursor, stage: *const Stage, focus: bool = false, pub fn draw(k: *const Stack, f: *sk.Frame, placed: anim.Placed) void { const box = k.stage.box(placed, .stack); const u = at(f, placed, box); const now = k.cursor.now(placed); const rec = k.cursor.rec; const slots = rowsOf(box); const body = u.panel(box.w, box.h, "stack", .{ .focus = k.focus, .note = u.print("{s} words from rsp \u{00b7} the frames they belong to", .{switch (slots) { 4 => "four", 8 => "eight", else => u.print("{d}", .{slots}), }}) }); const is = (now.moment().regs(rec.tid) catch null) orelse return; const was = (now.before().regs(rec.tid) catch null) orelse is; // The window is rsp's: when a step moves it the rows slide, with the // stack's words, a level after the registers (one onset at a time). const landed = now.landed(.memory, 0); const p = cursors.glide(now.moving(.memory, 0, time.move)); const moved = @as(f32, @floatFromInt(@as(i64, @bitCast(is.rsp -% was.rsp)))) / 8; const slide: f32 = if (@abs(moved) > 16) 0 else moved * (1 - p); const top = body.y + m.pad; clipBody(u, box); defer u.unclip(); // The addresses' shared digits: the rows read by their ends. const lead = ui.shared(&.{ is.rsp, is.rsp + 8 * @as(u64, slots) }); const memory = now.shown(.memory); var n: i64 = @as(i64, @intFromFloat(@floor(-slide))) - 1; while (n <= @as(i64, @intCast(slots)) - @as(i64, @intFromFloat(@floor(slide)))) : (n += 1) { const y = top + (@as(f32, @floatFromInt(n)) + slide) * m.row; if (y + m.row < body.y or y > box.h) continue; const addr = is.rsp +% @as(u64, @bitCast(n * 8)); // Who points here: a pin in the lane, landing with its link. const names = pins(u, now, is, was, addr); var marks: rows.Marks = .{ .lead = lead, .first = now.written(addr, 8, .memory, 0) }; if (now.wasRead(addr, 8) and now.writeAge(addr, 8) != 0) { marks.read = 0; marks.read_shows = now.reading(.memory, 0); } const hops = rows.slot(u, y, box.w, memory, addr, names.names, names.shows, marks); // Only a row on show is a place a tie can land. if (y >= top - 1 and y + m.row <= box.h - m.pad + 1) { ties.anchor(u, .{ .word = addr }, .{ .x = theme.metric.slot.chain, .y = y, .w = if (hops.n > 0) hops.x[0] + hops.w[0] - theme.metric.slot.chain else 120, .h = m.row }); ties.anchor(u, .{ .slot_pin = addr }, .{ .x = theme.metric.slot.lane, .y = y, .w = theme.metric.slot.lane_end - theme.metric.slot.lane, .h = m.row }); } } // The backtrace, drawn on the words that are each frame: it changes with the CPU. var buf: [16]Frame = undefined; const chain = frames(rec, if (landed) now.stops[0] else now.stops[1], &buf); // Placed as the rows are: against rsp after the step, and slid. const rsp = is.rsp; for (chain, 0..) |frame, i| { const first = @as(f32, @floatFromInt(@as(i64, @bitCast(frame.lo -% rsp)))) / 8 + slide; if (first >= @as(f32, @floatFromInt(slots))) break; const last = if (frame.hi) |hi| @as(f32, @floatFromInt(@as(i64, @bitCast(hi -% rsp)))) / 8 + slide else std.math.inf(f32); const open = last >= @as(f32, @floatFromInt(slots)); const y1 = top + (@min(last, @as(f32, @floatFromInt(slots)) - 1) + 1) * m.row; rows.span(u, box.w, top + @max(first, 0) * m.row, y1, frameName(u, rec, frame.pc), i == 0, open); } veiled(u, box, now.veil); } const Pins = struct { names: []const []const u8, shows: f32 }; /// The registers whose value is `addr`: before the step, and after it /// once their link has landed (`ties.pinShows`). fn pins(u: ui.Ui, now: cursors.Now, is: zt.Regs, was: zt.Regs, addr: u64) Pins { var out: std.ArrayList([]const u8) = .empty; var shows: f32 = 0; for (theme.metric.all_registers[0..16]) |name| { const i = index(name).?; const before = was.named(name) == addr; const after = is.named(name) == addr; if (!before and !after) continue; const s = ties.pinShows(now, i, .slot); const this = if (before and after) 1 else if (after) s.new else s.old; if (this < 0.5) continue; out.append(u.f.scratch, name) catch break; shows = @max(shows, this); } return .{ .names = out.items, .shows = shows }; } }; pub const Backtrace = struct { cursor: cursors.Cursor, stage: *const Stage, focus: bool = false, pub fn draw(b: *const Backtrace, f: *sk.Frame, placed: anim.Placed) void { const box = b.stage.box(placed, .backtrace); if (box.h < m.tag) return; const u = at(f, placed, box); const now = b.cursor.now(placed); const rec = b.cursor.rec; var buf: [24]Frame = undefined; const chain = frames(rec, now.stop(.cpu), &buf); const room = rowsOf(box); const body = u.panel(box.w, box.h, "backtrace", .{ .focus = b.focus, .note = if (chain.len > room) u.print("newest on top \u{00b7} {d} more", .{chain.len - room}) else "newest on top" }); clipBody(u, box); defer u.unclip(); for (chain[0..@min(chain.len, room)], 0..) |frame, i| { const y = body.y + m.pad + @as(f32, @floatFromInt(i)) * m.row; const name = ui.symbol(u, rec.strings.get(frame.pc) orelse u.print("{x}", .{frame.pc})); // The program's own frame says where in its source it is. const where = if (i == 0) u.print("{s}:{d}", .{ rec.file, rec.own[now.marked()] }) else ""; rows.callRow(u, y, box.w, i, name, where, i == 0); } veiled(u, box, now.veil); } }; test "the flags' bits" { try std.testing.expectEqual(@as(?usize, 17), index("eflags")); }