diff options
Diffstat (limited to 'anim/src/hexdump.zig')
| -rw-r--r-- | anim/src/hexdump.zig | 110 |
1 files changed, 103 insertions, 7 deletions
diff --git a/anim/src/hexdump.zig b/anim/src/hexdump.zig index 47283e7..21db91f 100644 --- a/anim/src/hexdump.zig +++ b/anim/src/hexdump.zig @@ -65,6 +65,8 @@ pub const Of = struct { things: []const objects.Object = &.{}, array: ?struct { addr: u64, len: u64, elem: u8, type: ?Recording.types.Type = null } = null, region: u24 = theme.color.region.heap, + /// A lens's view: a row a register points into carries its pin (`rowPin`). + pins: bool = false, }; /// The band's view of bytes: its own panel over the state column, the @@ -106,6 +108,7 @@ pub const Dump = struct { if (v.rows == 0) return; const now = d.cursor.now(placed); var of = d.of; + of.pins = true; of.watched = 0; while (of.watched + 1 < now.stops.len and now.stops[of.watched + 1] >= d.since) of.watched += 1; var shows: [8]f32 = @splat(0); @@ -151,7 +154,9 @@ pub const View = struct { /// always, with `loud`: a loupe's). `rule`: the panel's top and bottom, /// where a stub to a row past the window ends. pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize, of: Of) void { - drawArcs(u, now, x, y, first, count, of, false, .{ y - m.pad, y + @as(f32, @floatFromInt(count)) * m.row + m.pad }); + var view = of; + view.pins = true; + drawArcs(u, now, x, y, first, count, view, false, .{ y - m.pad, y + @as(f32, @floatFromInt(count)) * m.row + m.pad }); } pub fn drawArcs(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize, of: Of, loud: bool, rule: [2]f32) void { @@ -174,6 +179,7 @@ pub fn drawArcs(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: u moment.read(addr, &values, &known) catch return; var runs: [16]rows.Run = undefined; var readings: [16]Field = undefined; + var keeps: [16]bool = @splat(false); var n: usize = 0; var holds_drawn = false; var at: u64 = 0; @@ -206,6 +212,7 @@ pub fn drawArcs(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: u } run.heat = now.written(here, run.len, .memory, 0); run.changed = now.changedBytes(here, run.len); + if (now.struckAgo(here, run.len)) |ago| keeps[n] = ago < theme.time.strike.in / 2.0; if (now.wasRead(here, run.len) and now.writeAge(here, run.len) != 0) run.read = now.reading(.memory, 0); if (run.kind == .number or run.kind == .pointer) ties.anchor(v, .{ .dump_run = here }, .{ .x = shift + rows.byteX(run.first) - 4, .y = ry, .w = rows.byteX(run.first + run.len - 1) + 28 - rows.byteX(run.first) + 4, .h = m.row }); readings[n] = .{ .at = run.first, .len = run.len, .reads = switch (run.kind) { @@ -218,9 +225,11 @@ pub fn drawArcs(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: u at += run.len; } @import("map.zig").row(.view, addr, v, .{ .x = 0, .y = ry, .w = theme.layout.state.w, .h = m.row }); + keepOld(now, addr, &values, &known, runs[0..n], keeps[0..n]); rows.bytesAt(v, ry, addr, &values, &known, runs[0..n], of.region, lead, holds_drawn, moment, shift); if (pass + 1 == passes.n) for (runs[0..n]) |run| if (run.kind == .pointer and run.len == 8) pointerArcs(&arcs, now, addr + run.first, ry, shown_rows, 16, rule, loud, false); - const end = reading(v, ry, shift, moment, &values, &known, readings[0..n]); + const room = if (!of.pins) full_room else if (pass == 0) rowPin(dump, now, addr, ry) else rowPinRoom(dump, now, addr); + const end = readingIn(v, ry, shift, moment, &values, &known, readings[0..n], room); // The size word of the chunk after: malloc's, a note after the reading. const last = runs[n - 1]; if (last.kind == .loose and last.first == 8 and last.len == 8 and std.mem.indexOfScalar(bool, known[8..], false) == null and chunkAfter(moment, addr + 8)) { @@ -263,6 +272,65 @@ fn rowPasses(now: cursors.Now, addr: u64) Passes { return plain; } +/// The registers whose value is in the row `addr .. addr + 16`, as a step +/// moves them (`ties.pinShows`: a name joining or leaving fades through the +/// middle of its change), in pwndbg's order: a view's row a register points +/// into carries its pin, at the row's end (`Ui.pinEnd`). Draws it and +/// returns where the reading must end; publishes the row as a link's +/// target (`dump_pin`), its left edge. +fn rowPin(u: ui.Ui, now: cursors.Now, addr: u64, y: f32) f32 { + ties.anchor(u, .{ .dump_pin = addr }, .{ .x = 0, .y = y, .w = b.bracket, .h = m.row }); + const at = pinned(u, now, addr); + if (at.names.len == 0 or at.shows <= 0) return full_room; + const x = u.faded(at.shows).pinEnd(full_room, y, at.names, rows.ink(rows.regionOf(now.moment(), addr))); + return x - adv; +} + +/// Where the reading of a row must end for its pin (`rowPin`), not drawing it. +fn rowPinRoom(u: ui.Ui, now: cursors.Now, addr: u64) f32 { + const at = pinned(u, now, addr); + if (at.names.len == 0 or at.shows <= 0) return full_room; + const p = theme.metric.pin; + var shown: []const u8 = ""; + for (at.names[0..@min(at.names.len, 3)], 0..) |name, i| shown = if (i == 0) name else u.print("{s} {s}", .{ shown, name }); + if (at.names.len > 3) shown = u.print("{s} +{d}", .{ shown, at.names.len - 3 }); + return full_room - u.width(.mono, theme.size.mono.context, shown) - p.row_gap - p.row_head[0] - adv; +} + +fn pinned(u: ui.Ui, now: cursors.Now, addr: u64) struct { names: []const []const u8, shows: f32 } { + const rec = now.rec; + const context = @import("context.zig"); + const is = (now.moment().regs(rec.tid) catch null) orelse return .{ .names = &.{}, .shows = 0 }; + const was = (now.before().regs(rec.tid) catch null) orelse is; + var names: std.ArrayList([]const u8) = .empty; + var shows: f32 = 1; + for (theme.metric.all_registers[0..16]) |name| { + const in_was = if (was.named(name)) |v| v >= addr and v < addr + 16 else false; + const in_is = if (is.named(name)) |v| v >= addr and v < addr + 16 else false; + if (!in_was and !in_is) continue; + const s = ties.pinShows(now, context.index(name).?, .node); + const this: f32 = if (in_was and in_is) 1 else if (in_is) s.new else s.old; + if (in_was != in_is) shows = @min(shows, @abs(2 * this - 1)); + if (this < 0.5) continue; + names.append(u.f.scratch, name) catch break; + } + return .{ .names = names.items, .shows = shows }; +} + +/// The runs this step writes whose strike has not landed (`keeps`) keep +/// the bytes they had: the digits and the reading change at s+3, as the +/// fill comes in, never before the arm. +fn keepOld(now: cursors.Now, addr: u64, values: *[16]u8, known: *[16]bool, runs: []const rows.Run, keeps: []const bool) void { + if (std.mem.indexOfScalar(bool, keeps, true) == null) return; + var was: [16]u8 = undefined; + var known_was: [16]bool = undefined; + now.before().read(addr, &was, &known_was) catch return; + for (runs, keeps) |run, old| if (old) { + @memcpy(values[run.first..][0..run.len], was[run.first..][0..run.len]); + @memcpy(known[run.first..][0..run.len], known_was[run.first..][0..run.len]); + }; +} + /// A row of a panel: its first byte's address and its top. pub const RowAt = struct { addr: u64, y: f32 }; @@ -400,6 +468,11 @@ pub const Fields = struct { /// Seconds since its strikes began, a field 6 f after the one before /// (a loupe's, once it has opened); null: memory's slot. struck: ?f32 = null, + /// A view: a row a register points into carries its pin (`rowPin`). + pins: bool = false, + /// The fields before the step, where it retypes them: a run whose strike + /// has not landed is read as what it was. + was: []const Field = &.{}, }; /// The region's rows in view `v`, from `y`, sixteen bytes a row from its @@ -440,7 +513,8 @@ pub fn fielded(v: View, now: cursors.Now, y: f32, of: Fields) void { } last = r; const passes = rowPasses(now, of.base + 16 * r); - for (passes.moments[0..passes.n], passes.shows[0..passes.n]) |mm, shows| fieldRow(u.faded(shows), now, ry, of.base + 16 * r, if (passes.n == 2) mm else moment, of, lead, shift); + const room = if (of.pins) rowPin(u, now, of.base + 16 * r, ry) else full_room; + for (passes.moments[0..passes.n], passes.shows[0..passes.n]) |mm, shows| fieldRow(u.faded(shows), now, ry, of.base + 16 * r, if (passes.n == 2) mm else moment, of, lead, shift, room); at_rows.append(u.f.scratch, .{ .addr = of.base + 16 * r, .y = ry }) catch {}; @import("map.zig").row(.view, of.base + 16 * r, u, .{ .x = 0, .y = ry, .w = 860, .h = m.row }); ry += m.row; @@ -509,7 +583,7 @@ fn focus(now: cursors.Now, of: Fields, rs: []const u64) usize { return 0; } -fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Moment, of: Fields, lead: usize, shift: f32) void { +fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Moment, of: Fields, lead: usize, shift: f32, room: f32) void { var values: [16]u8 = undefined; var known: [16]bool = undefined; moment.read(addr, &values, &known) catch return; @@ -537,6 +611,7 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom }; var runs: [16]rows.Run = undefined; var readings: [16]Field = undefined; + var keeps: [16]bool = @splat(false); var n: usize = 0; var at: u8 = 0; while (at < 16 and addr + at < of.base + of.len) { @@ -558,6 +633,9 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom }; run.heat = now.writtenWatched(here, run.len, .memory, 0, 0, of.watched); run.changed = now.changedBytes(here, run.len); + // Until its own strike lands the old value stands: the loupe's own times, or memory's. + const ago = if (of.struck) |since| (if (now.walking() and now.writeAge(here, run.len) == 0) since - @as(f32, @floatFromInt(field_k)) * cursors.write_apart else null) else if (of.watched > 0) now.struckAgo(here, run.len) else null; + if (ago) |a| keeps[n] = a < theme.time.strike.in / 2.0; if (of.struck) |since| run.heat = now.writtenAt(here, run.len, since - @as(f32, @floatFromInt(field_k)) * cursors.write_apart); // What the kernel fills lands a byte every 2 f. if (@import("syscalls.zig").filledAt(now, here) != null) run.apart = 2; @@ -568,6 +646,16 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom if (of.watched > 0 and now.wasRead(here, run.len) and now.writeAge(here, run.len) != 0) framed = @max(framed, now.reading(.memory, 0)); run.read = framed; readings[n] = .{ .at = at, .len = run.len, .reads = fl.reads, .big = fl.big, .type = fl.type, .note = fl.note, .addr = here }; + // Its old bytes read as what they were until its strike lands (the step retypes the field: malloc's). + if (keeps[n]) for (of.was) |old| if (of.base + old.at <= here and here < of.base + old.at + old.len) { + readings[n] = .{ .at = at, .len = run.len, .reads = old.reads, .big = old.big, .type = old.type, .note = old.note, .addr = here }; + run.kind = switch (old.reads) { + .number, .bytes, .size, .protected => .number, + .pointer => .pointer, + .text => .text, + }; + break; + }; ties.anchor(u, .{ .dump_run = here }, .{ .x = shift + rows.byteX(run.first) - 4, .y = y, .w = rows.byteX(run.first + run.len - 1) + 28 - rows.byteX(run.first) + 4, .h = m.row }); } else { // Up to the next field, or the row's end. @@ -582,16 +670,17 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom n += 1; at += run.len; } + keepOld(now, addr, &values, &known, runs[0..n], keeps[0..n]); // The kernel reading them: one frame round what it took of the row. if (gives and of.read > 0) u.faded(of.read).frame(.{ .x = shift + rows.byteX(given_from) - 7, .y = y - 1, .w = rows.byteX(given_to) - rows.byteX(given_from) + 38, .h = m.row + 2 }, theme.mark(.read).solid, 2); const shows = if (of.given) |g| g.shows else 0; if (gives and shows > 0) { if (shows < 1) rows.bytesAt(u.faded(1 - shows), y, addr, &values, &known, runs[0..n], of.region, lead, true, moment, shift); rows.bytesAt(u.faded(shows), y, addr, &given_values, &given_known, runs[0..n], of.region, lead, true, moment, shift); - _ = reading(u.faded(shows), y, shift, moment, &given_values, &given_known, readings[0..n]); + _ = readingIn(u.faded(shows), y, shift, moment, &given_values, &given_known, readings[0..n], room); } else { rows.bytesAt(u, y, addr, &values, &known, runs[0..n], of.region, lead, true, moment, shift); - _ = reading(u, y, shift, moment, &values, &known, readings[0..n]); + _ = readingIn(u, y, shift, moment, &values, &known, readings[0..n], room); } } @@ -604,9 +693,16 @@ fn fieldRow(u: ui.Ui, now: cursors.Now, y: f32, addr: u64, moment: Recording.Mom /// `loose`, as nothing. Cut where the panel ends, with `…`. Returns where /// it ends. pub fn reading(u: ui.Ui, y: f32, shift: f32, moment: Recording.Moment, values: *const [16]u8, known: *const [16]bool, fields: []const Field) f32 { + return readingIn(u, y, shift, moment, values, known, fields, full_room); +} + +/// The panel's width less its side: where a reading ends with no pin at its row's end. +const full_room = theme.layout.state.w - theme.metric.context.side; + +/// `reading`, ending at `room` (a pin at the row's end takes the rest). +pub fn readingIn(u: ui.Ui, y: f32, shift: f32, moment: Recording.Moment, values: *const [16]u8, known: *const [16]bool, fields: []const Field, room: f32) f32 { const size = theme.size.mono.context; const base = rows.baseline(y); - const room = theme.layout.state.w - theme.metric.context.side; var x: f32 = b.reading + shift; for (fields) |fl| { const first: usize = @intCast(fl.at); |
