//! `hexdump` (design/README.md, "3. Panels"): memory as `bytes` rows, //! sixteen a row, the right half of a lens: the pane its drawing is a view //! of. A window of the region kept round the rows the step touches (five //! beside, nine as the subject), in address order; a gap in the addresses //! is one row of `more`'s dots and the count left out. Each row's runs //! come from the types of what the program's pointers reach: a field's //! bytes on raised paper in its ink, the allocator's dim, never read two //! dots; and its reading at 640: what the runs read as, little-endian. //! Bytes a step wrote are struck here before the drawing reacts. //! Reads `Moment.read`, `Moment.allocation`, and the recording's types. const std = @import("std"); const ui = @import("ui.zig"); const rows = @import("rows.zig"); const cursors = @import("cursor.zig"); const Recording = @import("Recording.zig"); const objects = @import("objects.zig"); const ties = @import("ties.zig"); const theme = ui.theme; const Rect = ui.Rect; const t = theme.color.text; const m = theme.metric.context; const b = theme.metric.bytes; const adv = theme.size.mono.context * 3 / 5; /// What a word of the region is. pub const Kind = enum { number, pointer, allocator, unread }; /// The kind of the word at `addr`: a field of a struct the program's /// pointers reach (by its type), other allocated bytes, the allocator's /// own between allocations, or never observed. pub fn kindOf(things: []const objects.Object, moment: Recording.Moment, addr: u64) Kind { for (things) |o| { if (!o.holds(addr)) continue; for (o.type.record.fields) |field| if (o.addr + field.offset == addr) return if (field.type == .pointer) .pointer else .number; return .number; } var bytes: [8]u8 = undefined; var known: [8]bool = undefined; moment.read(addr, &bytes, &known) catch return .unread; if (std.mem.indexOfScalar(bool, &known, true) == null) return .unread; return if ((moment.allocation(addr) catch null) != null) .number else .allocator; } /// The rows of a region (`lo .. hi`, sixteen-aligned) a dump of `count` /// rows shows: all of them, or a window round the first the step touched. pub fn window(now: cursors.Now, lo: u64, hi: u64, count: usize) u64 { const all = (hi - lo) / 16; if (all <= count) return lo; var touched: ?u64 = null; for ([_][]const Recording.Span{ now.rec.written(now.stops[1], now.stops[0]), now.rec.read(now.stops[1], now.stops[0]) }) |spans| for (spans) |span| { if (touched == null and span.addr >= lo and span.addr < hi) touched = span.addr & ~@as(u64, 15); }; const at = touched orelse lo; const row = (at - lo) / 16; const first = @min(row -| (count / 2), all - count); return lo + first * 16; } /// What a dump is of: the structs a drawing beside it draws, or an array /// of numbers (an element a run), and the ink of the memory it is in. pub const Of = struct { things: []const objects.Object = &.{}, array: ?struct { addr: u64, len: u64, elem: u8 } = null, region: u24 = theme.color.region.heap, }; /// The dump: `count` rows from `first`, at `x` (its panel's left edge /// is the band's middle), the rows from `y`. The rows of what the drawing /// draws have quiet brackets. pub fn draw(u: ui.Ui, now: cursors.Now, x: f32, y: f32, first: u64, count: usize, of: Of) void { const v = u.moved(x, 0); const moment = now.shown(.memory); const lead = ui.shared(&.{ first, first + 16 * @as(u64, count -| 1) }); for (0..count) |i| { const addr = first + 16 * i; const ry = y + @as(f32, @floatFromInt(i)) * m.row; var values: [16]u8 = undefined; var known: [16]bool = undefined; moment.read(addr, &values, &known) catch return; var runs: [16]rows.Run = undefined; var n: usize = 0; var holds_drawn = false; var at: u64 = 0; while (at < 16) { const here = addr + at; var run: rows.Run = .{ .first = @intCast(at), .len = 8, .kind = .unread }; if (of.array) |arr| if (here >= arr.addr and here < arr.addr + arr.len) { run.len = arr.elem; run.kind = .number; holds_drawn = true; }; if (run.kind == .unread) { // A word, or what is left of one before an array begins. run.len = @intCast(@min(8 - (here % 8), 16 - at)); if (of.array) |arr| if (here < arr.addr and arr.addr < here + run.len) { run.len = @intCast(arr.addr - here); }; run.kind = switch (kindOf(of.things, moment, here)) { .number => .number, .pointer => .pointer, .allocator => .allocator, .unread => .unread, }; for (of.things) |o| if (o.holds(here)) { holds_drawn = true; }; } run.heat = now.written(here, run.len, .memory, 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 = rows.byteX(run.first) - 4, .y = ry, .w = rows.byteX(run.first + run.len - 1) + 28 - rows.byteX(run.first) + 4, .h = m.row }); runs[n] = run; n += 1; at += run.len; } rows.bytes(v, ry, addr, &values, &known, runs[0..n], of.region, lead, holds_drawn, moment); reading(v, ry, moment, &values, &known, runs[0..n]); } } /// The reading: what the runs read as, little-endian. A number ranged /// right in three characters; a pointer as `points` and its address; /// `NULL` dim; an allocator's run as a note, faint. fn reading(u: ui.Ui, y: f32, moment: Recording.Moment, values: *const [16]u8, known: *const [16]bool, runs: []const rows.Run) void { const size = theme.size.mono.context; const base = rows.baseline(y); var x: f32 = b.reading; for (runs) |run| { var bytes: [8]u8 = @splat(0); @memcpy(bytes[0..run.len], values[run.first..][0..run.len]); const word = std.mem.readInt(u64, &bytes, .little); const whole = std.mem.indexOfScalar(bool, known[run.first..][0..run.len], false) == null; if (!whole) continue; switch (run.kind) { .number => { // A field typed a number reads as its decimal. const shift: u6 = @intCast(64 - 8 * @as(u32, @min(run.len, 8))); const digits = u.print("{d}", .{@as(i64, @bitCast(word << shift)) >> shift}); const w = @as(f32, @floatFromInt(digits.len)) * adv; u.text(.mono, size, x + @max(3 * adv - w, 0), base, digits, t.primary); x += @max(3 * adv, w) + 8; }, .pointer => if (word == 0) { u.text(.mono, size, x + theme.metric.context.arrow_w, base, "NULL", t.dim); x += theme.metric.context.arrow_w + 4 * adv + 8; } else { x = u.arrow(x, y + m.row / 2, .points); x = u.address(x, base, word, .{ .ink = ui.rgb(rows.ink(rows.regionOf(moment, word))) }) + 8; }, .allocator => if (run.first == 8 and run.len == 8) { // The size word of the chunk after: malloc's. u.text(.sans, theme.size.sans.micro, x, base - 1, u.print("malloc's: a chunk of {d}", .{word & ~@as(u64, 7)}), t.faint); return; }, .unread => {}, } } }