summaryrefslogtreecommitdiff
path: root/anim/src/descent.zig
diff options
context:
space:
mode:
Diffstat (limited to 'anim/src/descent.zig')
-rw-r--r--anim/src/descent.zig620
1 files changed, 620 insertions, 0 deletions
diff --git a/anim/src/descent.zig b/anim/src/descent.zig
new file mode 100644
index 0000000..302de38
--- /dev/null
+++ b/anim/src/descent.zig
@@ -0,0 +1,620 @@
+//! `descent` (design/README.md, "3. Panels"): the disassembly a level up,
+//! a call followed down. The panel is a stack of windows, one a call deep:
+//! the scene's function's on top, each callee's under the row that called
+//! it (that row `waiting`, ringed; a PLT stub gone through keeps its `jmp`,
+//! `pass`), a head row over each, the call lane from ring to head; and
+//! under the deepest, while a system call crosses, the kernel on vellum.
+//! Down is deeper, and the way back up is drawn.
+//!
+//! Every row has a key (an instruction's address, a head's function), so
+//! the panel at one moment and at the next are two lists of the same
+//! rows: a step is the rows both have gliding, and the others leaving or
+//! arriving, on the timetable of its verb (`descend`, `ascend`, `cross`;
+//! design/motion.md, "A call followed down", "A system call").
+const std = @import("std");
+const sk = @import("sketch");
+const anim = @import("anim");
+const ui = @import("ui.zig");
+const rows = @import("rows.zig");
+const cursors = @import("cursor.zig");
+const Recording = @import("Recording.zig");
+const ties = @import("ties.zig");
+const map = @import("map.zig");
+const context = @import("context.zig");
+const disasm = @import("disasm.zig");
+const syscalls = @import("syscalls.zig");
+const Stage = @import("stage.zig").Stage;
+const theme = ui.theme;
+const Rect = ui.Rect;
+const t = theme.color.text;
+const k = theme.color.on_kernel;
+const m = theme.metric.context;
+const c = theme.metric.insn;
+const size = theme.size.mono.context;
+const adv = size * 3 / 5;
+const Insn = disasm.Insn;
+
+/// Frames at 60 a second, as motion.md counts them.
+fn f(n: f32) f32 {
+ return n / 60.0;
+}
+
+fn clamp01(v: f32) f32 {
+ return std.math.clamp(v, 0, 1);
+}
+
+/// One step of `by` from where the cursor is, timed as its verb
+/// (design/motion.md, "A call followed down"): into a call (`descend`, 2.7
+/// s), on through a PLT stub's `jmp` (2.0 s), out by a `ret` (`ascend`, 2.3
+/// s), across into the kernel (`cross`: `syscalls.step`); any other walked.
+pub fn step(cur: cursors.Cursor, s: *anim.Frame, by: Recording.Stop) void {
+ const rec = cur.rec;
+ const from = cur.moment(s);
+ const to = rec.next(by, from);
+ for (rec.syscalls) |made| if (made.enter > from and made.enter <= to) return syscalls.step(cur, s, by);
+ if (to != from + 1) return cur.walk(s, by, to);
+ const b = rec.insn_branches[from] orelse return cur.walk(s, by, to);
+ var name_buf: [256]u8 = undefined;
+ const here = (rec.moment(from).string(rec.register(from, "rip"), &name_buf) catch null) orelse "";
+ const plan: cursors.Plan = switch (b.kind) {
+ .call => .{ .at = .{ f(24), f(60), f(60) }, .advance = f(126), .travel = f(12), .total = f(162) },
+ .ret => .{ .at = .{ f(36), f(18), f(36) }, .advance = f(102), .travel = f(12), .total = f(138) },
+ .jump => if (std.mem.indexOf(u8, here, "@plt") != null) .{ .at = .{ f(18), f(24), f(24) }, .advance = f(84), .travel = f(12), .total = f(120) } else return cur.walk(s, by, to),
+ .none => return cur.walk(s, by, to),
+ };
+ cur.step(s, to, plan, plan.total);
+}
+
+/// A row of the panel.
+const Item = struct {
+ key: u64,
+ row: f32,
+ /// The window it is in, 0 the top.
+ window: u8,
+ what: union(enum) { insn: Insn, head: struct { name: []const u8, note: []const u8 }, more: []const u8 },
+ state: enum { plain, waiting, pass, current } = .plain,
+ /// A waiting or passed row: the moment it ran.
+ at: u64 = 0,
+};
+
+/// The panel at a moment.
+const Layout = struct {
+ items: []Item,
+ /// Windows of code (a fold counts as none).
+ windows: usize,
+ /// The bottom three rows are the kernel's (the pc is at, or has just
+ /// come back from, a `syscall`).
+ kernel: bool,
+ /// The deepest function and its module: the panel's tag.
+ tag: []const u8,
+ in_stub: bool,
+};
+
+pub const Descent = struct {
+ cursor: cursors.Cursor,
+ stage: *const Stage,
+ focus: bool = false,
+ /// The function whose window is on top: where the scene follows from.
+ root: []const u8 = "main",
+
+ pub fn draw(d: *const Descent, fr: *sk.Frame, placed: anim.Placed) void {
+ const box = d.stage.box(placed, .disasm);
+ const u = context.at(fr, placed, box);
+ const now = d.cursor.now(placed);
+ const rec = d.cursor.rec;
+ const room = theme.layout.rowsIn(box.h);
+ const before = layout(u, rec, now.stops[1], room, d.root);
+ const after = layout(u, rec, now.stops[0], room, d.root);
+ const tm = now.time;
+ const going = now.advancing();
+ const kind: enum { same, down, through, up } = if (now.resting() or now.stops[0] == now.stops[1]) .same else if (after.windows > before.windows) (if (before.in_stub) .through else .down) else if (after.windows < before.windows) .up else .same;
+ const shown = if (going >= 0.5) after else before;
+ const body = u.panel(box.w, box.h, "disassembly", .{ .focus = d.focus, .note = shown.tag });
+ const top = body.y + m.pad;
+ u.clip(.{ .x = theme.stroke.rule, .y = m.tag, .w = box.w - 2 * theme.stroke.rule, .h = box.h - m.tag - theme.stroke.rule });
+ defer u.unclip();
+
+ // How far the rows both lists have are on their way, and how much
+ // of each that leaves or comes shows: the verb's timetable.
+ const move: f32 = switch (kind) {
+ .same => cursors.glide(going),
+ .down => cursors.glide(clamp01((tm - f(72)) / f(18))),
+ .through => cursors.glide(clamp01((tm - f(24)) / f(18))),
+ .up => cursors.glide(clamp01((tm - f(84)) / f(18))),
+ };
+ const Placed = struct { item: Item, y: f32, shows: f32, rise: f32, old: ?Item, new: ?Item };
+ var placed_items: std.ArrayList(Placed) = .empty;
+ const a = u.f.scratch;
+ // Leaving: bottom up when a window closes, all at once when a caller gives up rows.
+ var leaving: usize = 0;
+ var i = before.items.len;
+ while (i > 0) {
+ i -= 1;
+ const it = before.items[i];
+ if (find(after.items, it.key)) |_| continue;
+ const shows: f32 = switch (kind) {
+ .same => 1 - clamp01(2 * going),
+ .down => 1 - clamp01((tm - f(66)) / f(12)),
+ .through => 1 - clamp01((tm - f(24)) / f(12)),
+ .up => 1 - clamp01((tm - f(48) - @as(f32, @floatFromInt(leaving)) * f(2)) / f(12)),
+ };
+ leaving += 1;
+ placed_items.append(a, .{ .item = it, .y = top + it.row * m.row, .shows = shows, .rise = 0, .old = it, .new = null }) catch {};
+ }
+ // Arriving: a head rising, then its rows top down, 2 f apart.
+ var arriving: usize = 0;
+ for (after.items) |it| {
+ if (find(before.items, it.key)) |old| {
+ const y = top + std.math.lerp(old.row, it.row, move) * m.row;
+ // Going up the rows keep what they were (the ring) until the advance.
+ const now_item = switch (kind) {
+ .same, .up => if (going >= 0.5) it else old,
+ // The call row is current until its plaque becomes the ring; a stub's jmp until it passes.
+ .down => if (tm >= f(72)) it else old,
+ .through => if (tm >= f(24)) it else old,
+ };
+ placed_items.append(a, .{ .item = now_item, .y = y, .shows = 1, .rise = 0, .old = old, .new = it }) catch {};
+ continue;
+ }
+ const head = it.what == .head;
+ const shows: f32 = switch (kind) {
+ .same => clamp01(2 * going - 1),
+ .down => if (head) clamp01((tm - f(96)) / f(12)) else clamp01((tm - f(102) - @as(f32, @floatFromInt(arriving)) * f(2)) / f(12)),
+ .through => if (head) clamp01((tm - f(54)) / f(12)) else clamp01((tm - f(60) - @as(f32, @floatFromInt(arriving)) * f(2)) / f(12)),
+ .up => clamp01((tm - f(84)) / f(18)),
+ };
+ if (!head) arriving += 1;
+ placed_items.append(a, .{ .item = it, .y = top + it.row * m.row, .shows = shows, .rise = if (head and kind != .same) (1 - cursors.standard(shows)) * theme.time.caption_rise else 0, .old = null, .new = it }) catch {};
+ }
+ std.mem.sort(Placed, placed_items.items, {}, struct {
+ fn above(_: void, x: Placed, y: Placed) bool {
+ return x.y < y.y;
+ }
+ }.above);
+
+ // The marks: the pc's plaque, leaving the row it was on and landing
+ // on the next; the ring on a waiting call; a passed stub's bar.
+ const marked = now.marks[if (going >= 0.5) 1 else 0];
+ const plaque = [2]f32{
+ // The one it leaves: in a descend it becomes the ring (72 to 84 f),
+ // through a stub the pass bar (24 to 36), up it closes with its window.
+ switch (kind) {
+ .same => 1,
+ .down => 1 - clamp01((tm - f(72)) / f(12)),
+ .through => 1 - clamp01((tm - f(24)) / f(12)),
+ .up => 1 - clamp01((tm - f(48)) / f(12)),
+ },
+ // The one it lands on, with the advance.
+ if (kind == .same) 1 else clamp01(going * 2),
+ };
+ var pc_y = [2]?f32{ null, null };
+ for (placed_items.items) |p| {
+ if (p.old) |o| if (o.state == .current) {
+ pc_y[0] = p.y;
+ };
+ if (p.new) |n| if (n.state == .current) {
+ pc_y[1] = p.y;
+ };
+ }
+ // In one window the plaque slides from row to row, with the advance.
+ var mark: ?struct { y: f32, shows: f32 } = null;
+ if (kind == .same) {
+ if (pc_y[0] != null and pc_y[1] != null) mark = .{ .y = std.math.lerp(pc_y[0].?, pc_y[1].?, cursors.standard(going)), .shows = 1 } else if (pc_y[1]) |y| {
+ mark = .{ .y = y, .shows = clamp01(2 * going - 1) };
+ } else if (pc_y[0]) |y| {
+ mark = .{ .y = y, .shows = 1 - clamp01(2 * going) };
+ }
+ }
+ const fire = now.fires(.disasm);
+ if (mark) |mk| plaqueAt(u, box.w, mk.y, mk.shows, fire) else {
+ if (pc_y[0]) |y| if (going < 0.5) plaqueAt(u, box.w, y, plaque[0], fire);
+ if (pc_y[1]) |y| if (going >= 0.5) plaqueAt(u, box.w, y, plaque[1], 0);
+ }
+
+ // Which rows ran in the last three steps: the trail.
+ const ran = recentRows(a, now, if (going >= 0.5) 0 else 1);
+ const current_line = rec.own[marked];
+ const widen0 = rows.numberRoom(rec.line_count);
+ var covered: usize = 0;
+ var runs: disasm.Runs = .{};
+ var last_line: ?u32 = null;
+ var last_window: ?u8 = null;
+ const dd: disasm.Disasm = .{ .cursor = d.cursor, .stage = d.stage };
+ const base: usize = if (going >= 0.5) 0 else 1;
+ for (placed_items.items) |p| {
+ const v = u.faded(p.shows);
+ const y = p.y + p.rise;
+ if (p.shows <= 0) continue;
+ if (last_window == null or last_window.? != p.item.window) last_line = null;
+ last_window = p.item.window;
+ switch (p.item.what) {
+ .head => |h| {
+ v.fill(.{ .x = theme.stroke.rule, .y = y, .w = box.w - 2 * theme.stroke.rule, .h = theme.stroke.rule }, theme.color.rule);
+ v.text(.sans_medium, theme.size.sans.micro, c.address, y + 18, h.name, t.primary);
+ v.text(.sans, theme.size.sans.micro, box.w - m.side - v.width(.sans, theme.size.sans.micro, h.note), y + 18, h.note, t.faint);
+ covered -|= 1;
+ },
+ .more => |words| {
+ _ = v.arrow(c.address, y + m.row / 2, .more);
+ v.text(.mono, size, c.address + m.arrow_w + adv, rows.baseline(y), words, t.faint);
+ covered -|= 1;
+ },
+ .insn => |row| {
+ const window_items = windowOf(placed_items.items, p.item.window);
+ var addrs: [80]u64 = undefined;
+ var n: usize = 0;
+ for (window_items) |w| if (w.item.what == .insn and n < addrs.len) {
+ addrs[n] = w.item.key;
+ n += 1;
+ };
+ const lead = ui.shared(addrs[0..n]);
+ const wide = @as(f32, @floatFromInt(@max(ui.digits(row.addr), 7) - 7)) * adv;
+ const line = if (row.outside) null else row.line;
+ const state: disasm.Disasm.State = switch (p.item.state) {
+ // The row the plaque has not reached yet is ahead.
+ .current => if (p.old == null or p.old.?.state != .current) (if (going >= 0.5) .current else .ahead) else if (p.new == null or p.new.?.state != .current) (if (going < 0.5) .current else .ahead) else .current,
+ .waiting => .{ .waiting = p.item.at },
+ .pass => .{ .ran = .{ .k = 0, .at = p.item.at } },
+ .plain => if (ranOf(ran, row.addr)) |r| .{ .ran = r } else .ahead,
+ };
+ // The marks at the row's left: the trail, the ring, the pass.
+ switch (p.item.state) {
+ .plain => if (ranOf(ran, row.addr)) |r| v.trail(c.mark, y, r.k),
+ .pass => v.trail(c.mark, y, 0),
+ .waiting => {
+ // The ring comes as the plaque leaves; going up it becomes a trail bar.
+ const ring: f32 = if (p.old != null and p.old.?.state == .waiting) (if (kind == .up) 1 - clamp01((tm - f(102)) / f(12)) else 1) else if (kind == .down) clamp01((tm - f(72)) / f(12)) else 1;
+ ringAt(v.faded(ring), y);
+ if (ring < 1) v.faded(1 - ring).trail(c.mark, y, 0);
+ },
+ .current => {},
+ }
+ runs.add(line != null and line.? == current_line, y, y + m.row);
+ const hangs = dd.insn(v, now, row, y, box.w, widen0 + wide, line, line != last_line, current_line, lead, state, base, covered > 0, .{ addrs[0], addrs[n -| 1] }, null);
+ covered = @max(covered -| 1, hangs);
+ last_line = line;
+ map.row(.disasm, row.addr, u, .{ .x = 0, .y = y, .w = box.w, .h = m.row });
+ },
+ }
+ }
+ runs.add(false, box.h, box.h);
+ disasm.threadRuns(u, box.w, .{ .{}, runs }, 1);
+
+ // The call lane: from each waiting ring (or passed jmp) down to the
+ // head of the window under it, turning in to its name.
+ for (placed_items.items) |p| {
+ if (p.item.what != .head or p.item.window == 0) continue;
+ const from = for (placed_items.items) |q| {
+ if (q.item.window + 1 == p.item.window and (q.item.state == .waiting or q.item.state == .pass)) break q;
+ } else continue;
+ const drawn: f32 = if (p.old != null and p.new != null) 1 else if (p.new != null) switch (kind) {
+ .down => clamp01((tm - f(84)) / f(18)),
+ .through => clamp01((tm - f(42)) / f(18)),
+ else => clamp01(2 * going - 1),
+ } else switch (kind) {
+ .up => 1 - clamp01((tm - f(72)) / f(12)),
+ else => 1 - clamp01(2 * going),
+ };
+ if (drawn <= 0) continue;
+ const ya = from.y + m.row - 3;
+ const yb = p.y + m.row / 2;
+ u.route(&.{ .{ 14, ya }, .{ 14, yb }, .{ c.address - 4, yb } }, t.primary, .{ .width = theme.stroke.rule, .head = .{ 7, 8 }, .radius = 4, .progress = cursors.standard(drawn) });
+ }
+ map.window(.disasm, first(shown), last(shown));
+ if (pc_y[1] orelse pc_y[0]) |y| ties.anchor(u, .pc, .{ .x = 0, .y = y, .w = theme.metric.plaque.pc, .h = m.row });
+ kernel(u, now, box, top, room, pc_y[0] orelse pc_y[1]);
+ context.veiled(u, box, now.veil);
+ }
+};
+
+/// The pc's plaque on the row at `y`.
+fn plaqueAt(u: ui.Ui, w: f32, y: f32, shows: f32, fire: f32) void {
+ if (shows <= 0) return;
+ const v = u.faded(shows);
+ v.current(.{ .x = theme.stroke.rule, .y = y, .w = w - 2 * theme.stroke.rule, .h = m.row }, theme.metric.plaque.pc, fire);
+ sk.draw.polygon(u.f, &.{ .{ 20, y + m.row / 2 }, .{ 10, y + 6 }, .{ 10, y + m.row - 6 } }, v.at.pen(.{ .fill = ui.rgb(theme.mark(.current).on_solid) }));
+}
+
+/// `waiting`: the plaque's place ringed, a 2-unit primary frame 24 by 24
+/// with a primary head in it, as a waiting call node is; no wash.
+fn ringAt(u: ui.Ui, y: f32) void {
+ u.frame(.{ .x = c.mark + 1, .y = y + 1, .w = 22, .h = 22 }, t.primary, theme.stroke.rule);
+ sk.draw.polygon(u.f, &.{ .{ 19, y + m.row / 2 }, .{ 10, y + 7 }, .{ 10, y + m.row - 7 } }, u.at.pen(.{ .fill = ui.rgb(t.primary) }));
+}
+
+fn find(items: []const Item, key: u64) ?Item {
+ for (items) |it| if (it.key == key) return it;
+ return null;
+}
+
+fn windowOf(items: anytype, window: u8) @TypeOf(items) {
+ var lo: usize = items.len;
+ var hi: usize = 0;
+ for (items, 0..) |p, j| if (p.item.window == window) {
+ lo = @min(lo, j);
+ hi = j + 1;
+ };
+ return if (lo < hi) items[lo..hi] else items[0..0];
+}
+
+fn first(l: Layout) u64 {
+ for (l.items) |it| if (it.what == .insn) return it.key;
+ return 0;
+}
+
+fn last(l: Layout) u64 {
+ var out: u64 = 0;
+ for (l.items) |it| if (it.what == .insn) {
+ out = it.key;
+ };
+ return out;
+}
+
+const Ran = disasm.Disasm.Ran;
+const RanRow = struct { addr: u64, ran: Ran };
+
+/// The rows the last three steps ran (`base`: 1 while the mark is still
+/// on the step's first row), the newest step's mark on each.
+fn recentRows(a: std.mem.Allocator, now: cursors.Now, base: usize) []const RanRow {
+ var out: std.ArrayList(RanRow) = .empty;
+ for (0..3) |s| {
+ const from = now.stops[@min(base + 1 + s, now.stops.len - 1)];
+ const to = now.stops[base + s];
+ var at = to;
+ while (at > from and to - at < 512) {
+ at -= 1;
+ const pc = now.rec.register(at, "rip");
+ if (ranOf(out.items, pc) == null) out.append(a, .{ .addr = pc, .ran = .{ .k = s, .at = at } }) catch break;
+ // A return marks the call it comes back from: it has run, with its result.
+ if (now.rec.insn_branches[at]) |b| if (b.kind == .ret) {
+ var buf: [256]u8 = undefined;
+ const after = now.rec.instruction(at, b.to, &buf) orelse continue;
+ if (after.back == 0) continue;
+ const call = b.to - after.back;
+ if (ranOf(out.items, call) == null) out.append(a, .{ .addr = call, .ran = .{ .k = s, .at = madeAt(now.rec, at, call) } }) catch break;
+ };
+ }
+ }
+ return out.items;
+}
+
+fn ranOf(list: []const RanRow, addr: u64) ?Ran {
+ for (list) |r| if (r.addr == addr) return r.ran;
+ return null;
+}
+
+/// A level of the descent: a function's window.
+const Level = struct { at: u64, kind: enum { caller, pass, deepest }, name: []const u8, moment: u64 = 0 };
+
+/// The panel at moment `i`, `room` rows: the root's window on top, a
+/// window a call deep under it, the deepest round the pc, three at most
+/// (a longer chain keeps the first and the last two, the rest one row).
+fn layout(u: ui.Ui, rec: *const Recording, i: u64, room: usize, root: []const u8) Layout {
+ const a = u.f.scratch;
+ var items: std.ArrayList(Item) = .empty;
+ const pc = rec.register(i, "rip");
+ var buf: [24]context.Frame = undefined;
+ const chain = context.frames(rec, i, &buf);
+ var r: usize = 0;
+ for (chain, 0..) |fr, j| if (std.mem.eql(u8, context.frameName(u, rec, fr.pc), root)) {
+ r = j;
+ break;
+ };
+ var levels: [24]Level = undefined;
+ var n: usize = 0;
+ var j = r;
+ while (j > 0 and n + 2 < levels.len) : (j -= 1) {
+ const call = callBefore(u, rec, i, chain[j].pc) orelse break;
+ levels[n] = .{ .at = call.addr, .kind = .caller, .name = context.frameName(u, rec, chain[j].pc), .moment = madeAt(rec, i, call.addr) };
+ n += 1;
+ // Through a stub to a function that is not it: the stub's jmp, passed.
+ if (disasm.target(call)) |to| {
+ const stub = context.frameName(u, rec, to);
+ if (std.mem.endsWith(u8, stub, "@plt") and !std.mem.eql(u8, stub, context.frameName(u, rec, chain[j - 1].pc))) {
+ levels[n] = .{ .at = to, .kind = .pass, .name = stub, .moment = madeAt(rec, i, to) };
+ n += 1;
+ }
+ }
+ }
+ const here = context.frameName(u, rec, pc);
+ const in_stub = std.mem.endsWith(u8, here, "@plt");
+ levels[n] = .{ .at = pc, .kind = .deepest, .name = here };
+ n += 1;
+ // Folded past three windows: the first, then a row of `more`, then the last two.
+ var fold: []const u8 = "";
+ var kept: []const Level = levels[0..n];
+ var kept_buf: [3]Level = undefined;
+ if (n > 3) {
+ fold = u.print("{d} calls:", .{n - 3});
+ for (levels[1 .. n - 2]) |l| fold = u.print("{s} {s}", .{ fold, l.name });
+ kept_buf = .{ levels[0], levels[n - 2], levels[n - 1] };
+ kept = &kept_buf;
+ }
+ // At a `syscall`, or just back from one: the floor is the kernel's.
+ const at_syscall = isSyscall(rec, i, pc) or (i > 0 and isSyscall(rec, i - 1, rec.register(i - 1, "rip")) and rec.register(i - 1, "rip") + 2 == pc);
+ var fixed: usize = if (at_syscall and kept.len > 1) 3 else 0;
+ for (kept, 0..) |l, li| {
+ if (li > 0) fixed += 1;
+ fixed += switch (l.kind) {
+ .caller => 3,
+ .pass => 1,
+ .deepest => 0,
+ };
+ }
+ if (fold.len > 0) fixed += 1;
+ const remaining = room -| fixed;
+ const deepest_rows = if (kept.len == 1) room else if (in_stub) @min(remaining, stubRows(rec, i, pc)) else remaining;
+ const extra = remaining -| deepest_rows;
+ var row: f32 = 0;
+ var tag: []const u8 = "";
+ for (kept, 0..) |l, li| {
+ const window: u8 = @intCast(li);
+ if (li == 1 and fold.len > 0) {
+ items.append(a, .{ .key = std.hash.Wyhash.hash(1, fold), .row = row, .window = window, .what = .{ .more = fold } }) catch {};
+ row += 1;
+ }
+ if (li > 0) {
+ items.append(a, .{ .key = std.hash.Wyhash.hash(0, l.name) | 1 << 63, .row = row, .window = window, .what = .{ .head = .{ .name = l.name, .note = headNote(u, rec, i, l) } } }) catch {};
+ row += 1;
+ }
+ const nearest = li + 2 == kept.len and l.kind == .caller;
+ const count: usize = switch (l.kind) {
+ .caller => 3 + if (nearest) extra else 0,
+ .pass => 1,
+ .deepest => deepest_rows,
+ };
+ const above: usize = switch (l.kind) {
+ .caller => (count - 1) / 2,
+ .pass => 0,
+ // Under a `syscall` four rows hold its arguments.
+ .deepest => if (in_stub) 0 else if (isSyscall(rec, i, pc) and count > 5) count - 5 else (count -| 1) / 2,
+ };
+ const list = disasm.listingAt(u, rec, i, l.at, count, above);
+ for (list.rows, 0..) |insn, q| {
+ const on = q == list.pc;
+ items.append(a, .{ .key = insn.addr, .row = row + @as(f32, @floatFromInt(q)), .window = window, .what = .{ .insn = insn }, .state = if (!on) .plain else switch (l.kind) {
+ .caller => .waiting,
+ .pass => .pass,
+ .deepest => .current,
+ }, .at = l.moment }) catch {};
+ }
+ row += @floatFromInt(count);
+ if (l.kind == .deepest) tag = if (kept.len == 1) l.name else u.print("{s} \u{00b7} {s}", .{ l.name, moduleOf(u, rec, i, pc) });
+ }
+ return .{ .items = items.items, .windows = kept.len, .kernel = at_syscall, .tag = tag, .in_stub = in_stub };
+}
+
+/// The call instruction a return address `ret` comes back after.
+fn callBefore(u: ui.Ui, rec: *const Recording, i: u64, ret: u64) ?Insn {
+ var buf: [256]u8 = undefined;
+ const after = rec.instruction(i, ret, &buf) orelse return null;
+ if (after.back == 0) return null;
+ const at = ret - after.back;
+ const call = rec.instruction(i, at, &buf) orelse return null;
+ if (!std.mem.startsWith(u8, call.text, "call")) return null;
+ return .{ .addr = at, .len = call.len, .text = u.print("{s}", .{call.text}) };
+}
+
+/// The moment the instruction at `addr` last ran, at or before `i`.
+fn madeAt(rec: *const Recording, i: u64, addr: u64) u64 {
+ var at = i;
+ while (at > 0 and i - at < 4096) : (at -= 1) if (rec.register(at, "rip") == addr) return at;
+ return i;
+}
+
+fn isSyscall(rec: *const Recording, i: u64, pc: u64) bool {
+ var buf: [256]u8 = undefined;
+ const here = rec.instruction(i, pc, &buf) orelse return false;
+ return std.mem.eql(u8, here.text, "syscall");
+}
+
+/// How many instructions a PLT stub at `pc` has (three: its `jmp`, a push, a jmp to the resolver).
+fn stubRows(rec: *const Recording, i: u64, pc: u64) usize {
+ var buf: [256]u8 = undefined;
+ var at = pc;
+ var n: usize = 0;
+ while (n < 4) : (n += 1) {
+ const one = rec.instruction(i, at, &buf) orelse break;
+ if (n > 0 and one.back == 0) break;
+ at += one.len;
+ }
+ return @max(n, 1);
+}
+
+/// A window's head note: what the code is (`libc.so.6 · no source`,
+/// `the PLT · its jmp reads open@got, 403fd8`, the program's file).
+fn headNote(u: ui.Ui, rec: *const Recording, i: u64, l: Level) []const u8 {
+ if (std.mem.endsWith(u8, l.name, "@plt")) {
+ if (l.kind == .pass) return "the PLT, jumped through";
+ var buf: [256]u8 = undefined;
+ const jmp = rec.instruction(i, l.at, &buf) orelse return "the PLT";
+ const ops = std.mem.trim(u8, jmp.text[(std.mem.indexOfScalar(u8, jmp.text, ' ') orelse jmp.text.len)..], " ");
+ const at = std.mem.indexOf(u8, ops, "[rip + 0x") orelse return "the PLT";
+ const close = std.mem.indexOfScalarPos(u8, ops, at, ']') orelse return "the PLT";
+ const slot = l.at + jmp.len + (std.fmt.parseInt(u64, ops[at + 9 .. close], 16) catch return "the PLT");
+ const named = ui.symbol(u, rec.strings.get(slot) orelse "");
+ return u.print("the PLT \u{00b7} its jmp reads {s}, {x}", .{ named[0 .. std.mem.lastIndexOfScalar(u8, named, '+') orelse named.len], slot });
+ }
+ const module = moduleOf(u, rec, i, l.at);
+ if (std.mem.eql(u8, module, "[vdso]")) return "vdso \u{00b7} the kernel's code, run here";
+ var buf: [256]u8 = undefined;
+ if ((@import("ztrace").telescope.instruction(rec.moment(i), l.at, &buf) catch null)) |here| if (here.line != null) return rec.file;
+ return u.print("{s} \u{00b7} no source", .{module});
+}
+
+/// The file `addr`'s mapping is of, by its base name.
+fn moduleOf(u: ui.Ui, rec: *const Recording, i: u64, addr: u64) []const u8 {
+ var name: []const u8 = "";
+ var buf: [256]u8 = undefined;
+ _ = (rec.moment(i).mapping(addr, &name, &buf) catch null) orelse return "";
+ return u.print("{s}", .{std.fs.path.basename(name)});
+}
+
+/// The kernel's window, at the floor, while a step crosses: the crossing
+/// lane down from the pc's plaque, the vellum filling down from its head,
+/// the head and the call in C's form, `returns` and what crossed back
+/// with what it clobbered; the answer up the lane; and at the advance the
+/// window drawing back up into the lane.
+fn kernel(u: ui.Ui, now: cursors.Now, box: Rect, top: f32, room: usize, pc_y: ?f32) void {
+ if (!now.crossings or !now.walking()) return;
+ const made = syscalls.inStep(now) orelse return;
+ const rec = now.rec;
+ const p = syscalls.Plan.of(made);
+ const tm = now.time;
+ const y0 = top + @as(f32, @floatFromInt(room -| 3)) * m.row;
+ const from = (pc_y orelse y0 - m.row) + m.row;
+ const back_up = clamp01((tm - now.plan.advance) / f(12));
+ // The lane: down 24 f from the plaque, 3 units of vellum; back into it after the window.
+ const down = cursors.standard(clamp01((tm - p.enters) / syscalls.Plan.cross));
+ const lane_gone = clamp01((tm - now.plan.advance - f(12)) / f(12));
+ if (down > 0 and lane_gone < 1) {
+ const end = std.math.lerp(from, y0 + 4, down * (1 - lane_gone));
+ u.fill(.{ .x = 14 - 1.5, .y = from, .w = 3, .h = @max(end - from, 0) }, theme.color.kernel);
+ }
+ // The answer climbs the lane to the `syscall` row: a head of vellum going up it.
+ const climb = cursors.standard(clamp01((tm - p.back) / syscalls.Plan.cross));
+ if (climb > 0 and climb < 1) {
+ const yh = std.math.lerp(y0, from, climb);
+ sk.draw.polygon(u.f, &.{ .{ 14, yh - 8 }, .{ 7, yh + 2 }, .{ 21, yh + 2 } }, u.at.pen(.{ .fill = ui.rgb(theme.color.kernel) }));
+ }
+ const opens = cursors.standard(clamp01((tm - p.enters - f(18)) / f(12))) * (1 - back_up);
+ if (opens <= 0) return;
+ const h = 3 * m.row * opens;
+ u.fill(.{ .x = theme.stroke.rule, .y = y0, .w = box.w - 2 * theme.stroke.rule, .h = h }, theme.color.kernel);
+ u.clip(.{ .x = 0, .y = y0, .w = box.w, .h = h });
+ defer u.unclip();
+ // The lane's head, in ink on the vellum.
+ sk.draw.polygon(u.f, &.{ .{ 14, y0 + 10 }, .{ 10, y0 + 2 }, .{ 18, y0 + 2 } }, u.at.pen(.{ .fill = ui.rgb(k.ink) }));
+ const name = @import("ztrace").syscalls.name(made.nr) orelse "syscall";
+ const head = u.faded(clamp01((tm - p.enters - f(30)) / f(6)));
+ head.text(.sans_medium, theme.size.sans.micro, c.address, y0 + 18, "the kernel", k.ink);
+ const what = u.print("{s}, system call {d}", .{ name, made.nr });
+ head.text(.sans, theme.size.sans.micro, box.w - m.side - u.width(.sans, theme.size.sans.micro, what), y0 + 18, what, k.dim);
+ // The call in C's form, as the kernel took it.
+ const names = @import("ztrace").syscalls.names(made.nr);
+ const n = @min(@import("ztrace").syscalls.signature(made.nr).len, 6);
+ var call: []const u8 = u.print("{s}(", .{name});
+ for (0..n) |j| call = u.print("{s}{s}{s}", .{ call, if (j > 0) ", " else "", disasm.argument(u, rec, made.enter, if (j < names.len) names[j] else "", made.args[j]) });
+ call = u.print("{s})", .{call});
+ u.faded(clamp01((tm - p.enters - f(36)) / f(6))).text(.mono, size, c.address, rows.baseline(y0 + m.row), rows.fitted(u, call, box.w - m.side - c.address), k.ink);
+ // `returns`: the value, struck as it lands in the kernel's rows.
+ const ry = y0 + 2 * m.row;
+ const returns = tm - p.returns;
+ u.faded(clamp01((tm - p.enters - f(36)) / f(6))).text(.mono, size, c.address, rows.baseline(ry), "returns", k.dim);
+ if (returns >= 0 and made.exit != null) {
+ const got: i64 = @bitCast(made.result);
+ const value = u.print("{d}", .{got});
+ const x = c.address + 8 * adv;
+ const cell: Rect = .{ .x = x, .y = ry, .w = @as(f32, @floatFromInt(value.len)) * adv, .h = m.row };
+ const heat = now.heat(0, null, returns);
+ const ink = u.written(cell, heat) orelse ui.Ink{ .ink = ui.rgb(k.ink) };
+ u.text(ink.face, size, x, rows.baseline(ry), value, ink.ink);
+ var end = x + cell.w + adv;
+ const on = rec.openOn(u.f.scratch, made.result, made.exit.? + 1);
+ if (std.mem.eql(u8, name, "openat") or std.mem.eql(u8, name, "open")) if (on.len > 0) {
+ u.text(.mono, size, end, rows.baseline(ry), on, k.dim);
+ end += u.width(.mono, size, on) + 2 * adv;
+ };
+ u.text(.mono, size, end + adv, rows.baseline(ry), "rcx, r11: clobbered", k.dim);
+ }
+}