diff options
Diffstat (limited to 'anim/src')
| -rw-r--r-- | anim/src/context.zig | 7 | ||||
| -rw-r--r-- | anim/src/cursor.zig | 21 | ||||
| -rw-r--r-- | anim/src/disasm.zig | 93 |
3 files changed, 93 insertions, 28 deletions
diff --git a/anim/src/context.zig b/anim/src/context.zig index 8e0156d..7d56c62 100644 --- a/anim/src/context.zig +++ b/anim/src/context.zig @@ -262,9 +262,10 @@ pub const Registers = struct { const since = now.since(.cpu, delay); if (age == 0 and now.walking() and since >= 0) marks.extend = since; } - // At a run a value changes in place under an 8 f crossfade, unmarked, never in a frame. + // At a run a value changes in place under an 8 f crossfade, unmarked, never in a frame; so does its chain where what it reads changed. const ran = runFade(now, .cpu); - if (ran < 1 and value_was != value_now) _ = rows.reg(u.faded(1 - ran), y, w, name, was.moment, value_was, marks); + const fades = ran < 1 and (value_was != value_now or cursors.chainMoved(was.moment, is.moment, value_now)); + if (fades) _ = rows.reg(u.faded(1 - ran), y, w, name, was.moment, value_was, marks); // Its chain reads memory as the panels show it: what the step writes // there is followed again (`extend`) once the bytes have landed, never before. var memory = if (landed or ran < 1) is.moment else was.moment; @@ -272,7 +273,7 @@ pub const Registers = struct { memory, const again, marks.hops = now.following(value_now); if (again) |ago| marks.extend = @min(marks.extend orelse ago, ago); } - const hops = rows.reg(if (ran < 1 and value_was != value_now) u.faded(ran) else u, y, w, name, memory, if (landed or ran < 1) value_now else value_was, marks); + const hops = rows.reg(if (fades) u.faded(ran) else u, y, w, name, memory, if (landed or ran < 1) value_now else value_was, marks); fdNote(u.faded(note_shows), hops, y, note); anchor(u, i, hops, y, if (landed or ran < 1) value_now else value_was, w); } diff --git a/anim/src/cursor.zig b/anim/src/cursor.zig index e9aab67..b09db8d 100644 --- a/anim/src/cursor.zig +++ b/anim/src/cursor.zig @@ -866,6 +866,18 @@ pub fn jumps(rec: *const Recording, from: u64, to: u64) bool { return a.src != b.src or rec.depths[from] != rec.depths[to] or rows > time.current_jump_rows; } +/// Whether the chain from `value` reads otherwise at `is` than at `was` (the +/// values and texts of its hops). +pub fn chainMoved(was: Recording.Moment, is: Recording.Moment, value: u64) bool { + var bufs: [2][6]zt.telescope.Link = undefined; + var texts: [2][48]u8 = undefined; + const a = zt.telescope.chase(was, value, &bufs[0], &texts[0]) catch return false; + const b = zt.telescope.chase(is, value, &bufs[1], &texts[1]) catch return false; + if (a.len != b.len) return true; + for (a, b) |x, y| if (x.value != y.value or !std.mem.eql(u8, x.text, y.text)) return true; + return false; +} + /// The cursor at one instant. pub const Now = struct { rec: *const Recording, @@ -1188,14 +1200,7 @@ pub const Now = struct { const land = time.strike.in / 2.0; // Followed again only while that shows (its hops 4 f apart, 6 f each). if (struck < 0 or struck > land + 0.5) return .{ memory, null, 1 }; - var bufs: [2][6]zt.telescope.Link = undefined; - var texts: [2][48]u8 = undefined; - const was = zt.telescope.chase(n.before(), value, &bufs[0], &texts[0]) catch return .{ memory, null, 1 }; - const is = zt.telescope.chase(n.moment(), value, &bufs[1], &texts[1]) catch return .{ memory, null, 1 }; - const same = was.len == is.len and for (was, is) |a, b| { - if (a.value != b.value or !std.mem.eql(u8, a.text, b.text)) break false; - } else true; - if (same) return .{ memory, null, 1 }; + if (!chainMoved(n.before(), n.moment(), value)) return .{ memory, null, 1 }; if (!n.landedAt(value, 8)) return .{ memory, null, 1 - std.math.clamp(struck / land, 0, 1) }; return .{ memory, struck - 4.0 / 60.0, 1 }; } diff --git a/anim/src/disasm.zig b/anim/src/disasm.zig index 6c9e2dc..f61c721 100644 --- a/anim/src/disasm.zig +++ b/anim/src/disasm.zig @@ -77,6 +77,14 @@ pub const Disasm = struct { measures: bool = true, /// Its window this many rows whatever its box (a `pair`'s stopped run: the box shortens over its lower rows). rows: ?usize = null, + /// A `pair`'s: its run's name before the function's on the tag (`plain ยท fill`). + run: []const u8 = "", + /// A `pair`'s alignment: the pc's line's first row at the window's top while + /// the pc is in its upper half, so that two runs' rows of one line start level. + aligned: bool = false, + /// A `pair`'s stopped run, 0 to 1: the call at the pc never returned. Its + /// row reads so, the plaque goes, the tag says `stopped`. + stopped: ?anim.Value = null, pub fn draw(d: *const Disasm, f: *sk.Frame, placed: anim.Placed) void { const box = d.stage.box(placed, .disasm); @@ -84,13 +92,14 @@ pub const Disasm = struct { const now = d.cursor.now(placed); const rec = d.cursor.rec; const room = d.rows orelse theme.layout.rowsIn(box.h); + const stop = if (d.stopped) |v| placed.value(v) else 0; // The mark: it moves last, with the source's and rip. const going = now.advancing(); - const from = listing(u, rec, now.marks[0], room); - const to = listing(u, rec, now.marks[1], room); + const from = listing(u, rec, now.marks[0], room, d.aligned); + const to = listing(u, rec, now.marks[1], room, d.aligned); // On the map its box is as long as the instructions the recording has round the pc. // (Of the moment the pane shows: a continue's destination repacks the map as the pane goes there, not as it sets off.) - if (ui.mapping and d.measures) map.measure(.disasm, listing(u, rec, now.marks[if (going >= 0.5) 1 else 0], theme.map.disasm_rows).rows.len); + if (ui.mapping and d.measures) map.measure(.disasm, listing(u, rec, now.marks[if (going >= 0.5) 1 else 0], theme.map.disasm_rows, false).rows.len); const pc = [2]u64{ rec.register(now.marks[0], "rip"), rec.register(now.marks[1], "rip") }; // The function's name: one that changes with the advance crossfades over it. @@ -98,12 +107,16 @@ pub const Disasm = struct { for (pc, &names) |at_pc, *name| { const sym = rec.strings.get(at_pc) orelse ""; name.* = sym[0 .. std.mem.lastIndexOfScalar(u8, sym, '+') orelse sym.len]; + if (d.run.len > 0) name.* = u.print("{s} \u{00b7} {s}", .{ d.run, name.* }); } const renamed = !std.mem.eql(u8, names[0], names[1]); - const body = u.panel(box.w, box.h, "disassembly", .{ .focus = d.focus, .note = if (renamed) "" else names[1] }); + const body = u.panel(box.w, box.h, "disassembly", .{ .focus = d.focus, .note = if (renamed or stop > 0) "" else names[1] }); if (renamed) { u.faded(1 - going).tagNote(box.w, names[0]); u.faded(going).tagNote(box.w, names[1]); + } else if (stop > 0) { + u.faded(1 - stop).tagNote(box.w, names[1]); + u.faded(stop).tagNote(box.w, u.print("{s} \u{00b7} stopped", .{names[1]})); } const top = body.y + m.pad; // The rows' own room: a row going out of the window passes under the padding, its block's rule too. @@ -161,8 +174,8 @@ pub const Disasm = struct { // The pc's row: gold ember across, a plaque with an ink triangle. const gold = theme.mark(.current); const out = now.fires(.disasm); - if (mark_shows > 0) { - const v = u.faded(mark_shows); + if (mark_shows * (1 - stop) > 0) { + const v = u.faded(mark_shows * (1 - stop)); v.current(.{ .x = theme.stroke.rule, .y = mark_y, .w = box.w - 2 * theme.stroke.rule, .h = m.row }, theme.metric.plaque.pc, out); sk.draw.polygon(u.f, &.{ .{ 20, mark_y + m.row / 2 }, .{ 10, mark_y + 6 }, .{ 10, mark_y + m.row - 6 } }, v.at.pen(.{ .fill = ui.rgb(gold.on_solid) })); ties.anchor(u, .pc, .{ .x = 0, .y = mark_y, .w = theme.metric.plaque.pc, .h = m.row }); @@ -233,9 +246,10 @@ pub const Disasm = struct { ties.anchor(u, .{ .row = row.addr }, .{ .x = 0, .y = y, .w = box.w, .h = m.row }); const is_pc = row.addr == pc[if (going >= 0.5) 1 else 0]; // The row as before the advance and as after it (its state, its trail, its - // line number): where they differ, the one crossfades to the other over the - // advance's middle, never in a frame. - const across: f32 = if (now.resting()) 1 else std.math.clamp((going - 0.25) * 2, 0, 1); + // line number, the moment its annotation reads): where they differ, the one + // crossfades to the other over the advance's middle, at a run over the whole + // advance (the run's ease, 8 f, as a dump's values), never in a frame. + const across: f32 = if (now.resting()) 1 else if (now.plan.gait == .run) going else std.math.clamp((going - 0.25) * 2, 0, 1); var hangs: usize = 0; for ([2]usize{ 1, 0 }) |b| { const cur_s = rec.shown[now.marks[1 - b]]; @@ -248,10 +262,17 @@ pub const Disasm = struct { const cur_o = rec.shown[now.marks[1 - o]]; const line_o = if (row.outside or row.src != cur_o.src) null else row.line; const pc_o = row.addr == pc[1 - o]; - const same = pc_s == pc_o and std.meta.eql(line_s, line_o) and cur_s.line == cur_o.line and std.meta.eql(was_s, if (pc_o) null else rans[1 - o][j]); + const same = pc_s == pc_o and (!pc_s or now.marks[1 - b] == now.marks[1 - o]) and std.meta.eql(line_s, line_o) and cur_s.line == cur_o.line and std.meta.eql(was_s, if (pc_o) null else rans[1 - o][j]); const alpha: f32 = if (same) (if (main) 1 else 0) else if (b == 0) across else 1 - across; if (alpha <= 0) continue; - const v = lit.faded(alpha); + // A stopped run's call (`stopped`): the row as run, `never returned`, crossfading from the pc's. + const gone: f32 = if (pc_s) stop else 0; + if (gone > 0) { + const ran: Ran = .{ .k = 0, .at = now.marks[1 - b] }; + lit.faded(alpha * gone).trail(c.mark, y, ran.k); + _ = d.insn(lit.faded(alpha * gone), now, row, y, map.content(box.w), widen, line_s, line_s != last_line, cur_s.line, lead, .{ .ran = ran }, b, covered > 0, window, echo); + } + const v = lit.faded(alpha * (1 - gone)); if (was_s) |r| v.trail(c.mark, y, r.k); const h = d.insn(v, now, row, y, map.content(box.w), widen, line_s, line_s != last_line, cur_s.line, lead, state, b, covered > 0, window, echo); if (main) hangs = h; @@ -332,7 +353,7 @@ pub const Disasm = struct { // When the operands and the annotation do not both fit: the // annotation moves left (never past its column), then the operands give way. const ops = shorn(u, row); - const stub = if (target(row)) |to| pltName(u, rec, to) else ""; + const stub = if (target(row)) |to| (if (d.never(now, row, state, base)) bareName(u, rec, to) else pltName(u, rec, to)) else ""; var x = room + gap; if (need.drawn) x = annotationX(operandsWidth(u, row, ops, stub), room, need.end - annotationColumn()); operands(u, row, ops, stub, base_y, (if (covered) @min(x, annotationColumn()) else x) - gap - c.operands, if (pad) t.faint else theme.color.code.plain); @@ -340,6 +361,12 @@ pub const Disasm = struct { return if (need.drawn and !covered) d.annotation(u, now, row, y, x, room, state, base, window, echo).hangs else 0; } + /// A stopped run's call that has run and not come back (`stopped`, mock 38). + fn never(d: *const Disasm, now: cursors.Now, row: Insn, state: State, base: usize) bool { + if (d.stopped == null or state != .ran or !std.mem.eql(u8, row.mnemonic(), "call")) return false; + return returned(d.cursor.rec, row, state.ran.at, now.stops[base]) == null; + } + /// Whether `row` has an annotation: where it has none, its block's visits may be ranged right. pub fn noted(d: *const Disasm, u: ui.Ui, now: cursors.Now, row: Insn, y: f32, state: State, base: usize, window: [2]u64, echo: ?Echo) bool { return d.annotation(u.faded(0), now, row, y, annotationColumn(), std.math.inf(f32), state, base, window, echo).drawn; @@ -397,6 +424,8 @@ pub const Disasm = struct { if (stub) note.hangs = a.arguments(row, b.to, moment); return note; } + // A stopped run's call (`stopped`): its callee named on its address, and it never came back. + if (d.never(now, row, state, base)) return a.said("never returned", t.dim); var note = a.callee(b.to, moment); // Its arguments hang under it, a small `reg` a row, as many as the prototype has. if (state == .current) note.hangs = a.arguments(row, b.to, moment); @@ -1225,11 +1254,16 @@ fn cells(u: ui.Ui, x: f32, base_y: f32, bytes: u8) void { /// A PLT stub's name, for a call or a jump to one: `open@plt`; "" otherwise. fn pltName(u: ui.Ui, rec: *const Recording, to: u64) []const u8 { - const name = ui.symbol(u, rec.strings.get(to) orelse return ""); - const stub = name[0 .. std.mem.lastIndexOfScalar(u8, name, '+') orelse name.len]; + const stub = bareName(u, rec, to); return if (std.mem.endsWith(u8, stub, "@plt")) stub else ""; } +/// The function at `to`, by name ("" where it has none). +fn bareName(u: ui.Ui, rec: *const Recording, to: u64) []const u8 { + const name = ui.symbol(u, rec.strings.get(to) orelse return ""); + return name[0 .. std.mem.lastIndexOfScalar(u8, name, '+') orelse name.len]; +} + /// How wide operands `ops` of `row` are, whole (a target with its stub's name `stub`). fn operandsWidth(u: ui.Ui, row: Insn, ops: Operands, stub: []const u8) f32 { if (target(row)) |to| return @as(f32, @floatFromInt(ui.digits(to) + if (stub.len > 0) stub.len + 1 else 0)) * adv; @@ -1307,14 +1341,39 @@ fn full(name: []const u8) ?[]const u8 { /// `room` rows round the pc at moment `i`: in a pane, as many above as /// below; on the map, the function from its start where the pc is in its /// first three quarters of the rows (a strip's column stays still while -/// the pc walks it), else round the pc. -fn listing(u: ui.Ui, rec: *const Recording, i: u64, room: usize) Listing { +/// the pc walks it), else round the pc. `aligned` (a `pair`'s): no more +/// rows over the pc than its line has before it, so that the line's first +/// row is the window's top while the pc is in the window's upper half. +fn listing(u: ui.Ui, rec: *const Recording, i: u64, room: usize, aligned: bool) Listing { const pc = rec.register(i, "rip"); if (ui.mapping) { const whole = listingAt(u, rec, i, pc, room, room * 3 / 4); if (whole.pc < room * 3 / 4) return whole; } - return listingAt(u, rec, i, pc, room, (room -| 1) / 2); + const above = (room -| 1) / 2; + if (!aligned) return listingAt(u, rec, i, pc, room, above); + const l = listingAt(u, rec, i, pc, room, ofLine(rec, i, pc, above)); + // Where the code ends under the pc, the window is filled from above (as far as it would be unaligned). + if (l.rows.len < room and l.pc < above) return listingAt(u, rec, i, pc, room, @min(above, l.pc + room - l.rows.len)); + return l; +} + +/// How many of the `most` instructions just before `pc` are of its line (`most` where it has none). +fn ofLine(rec: *const Recording, i: u64, pc: u64, most: usize) usize { + var buf: [256]u8 = undefined; + const here = rec.instruction(i, pc, &buf) orelse return most; + const line = here.line orelse return most; + const src = here.src; + var back = here.back; + var addr = pc; + var n: usize = 0; + while (n < most and back != 0) : (n += 1) { + addr -= back; + const one = rec.instruction(i, addr, &buf) orelse break; + if (one.line == null or one.line.? != line or one.src != src) break; + back = one.back; + } + return n; } /// The same round the instruction at `pc` (in the window, `Listing.pc`). |
