summaryrefslogtreecommitdiff
path: root/anim/src/Recording.zig
diff options
context:
space:
mode:
Diffstat (limited to 'anim/src/Recording.zig')
-rw-r--r--anim/src/Recording.zig162
1 files changed, 137 insertions, 25 deletions
diff --git a/anim/src/Recording.zig b/anim/src/Recording.zig
index 92bb917..280d14a 100644
--- a/anim/src/Recording.zig
+++ b/anim/src/Recording.zig
@@ -75,6 +75,9 @@ pub const Branch = struct { to: u64, taken: bool, kind: enum(u8) { none, call, j
/// the program stopped there.
pub const CodeLine = struct { addr: u64, line: u32 };
+/// A variable on the stack, declared at a moment.
+pub const Declared = struct { moment: u64, addr: u64 };
+
/// Where a cursor's step may end.
pub const Stop = enum {
/// The next moment, whatever the recorder made one: an instruction, a line.
@@ -113,9 +116,11 @@ calls: []Call = &.{},
syscalls: []Syscall = &.{},
marks: []Mark = &.{},
allocations: []Born = &.{},
-/// For each moment, a bit for each register of `Regs.names` it changed.
-registers: []u32 = &.{},
+/// The registers of `tid` after each moment (the last known, before any).
+registers: []zt.Regs = &.{},
write_spans: Spans = .{},
+/// What instructions stored, changed or not (a recording by instruction).
+store_spans: Spans = .{},
read_spans: Spans = .{},
/// For each moment, what the instruction at its pc touches and where it branches.
insn_touches: [][2]?Touch = &.{},
@@ -123,6 +128,11 @@ insn_branches: []?Branch = &.{},
/// Every instruction address the program stopped at in its own source,
/// with that line, in address order.
code_lines: []CodeLine = &.{},
+/// Each local variable's declaration, in the order they came: in a
+/// recording that tells no calls, what says when a local began.
+locals: []Declared = &.{},
+/// The variables declared outside the stack (globals): bytes a lens draws.
+globals: []Span = &.{},
strings: std.AutoHashMapUnmanaged(u64, []const u8) = .empty,
arena: std.heap.ArenaAllocator,
@@ -237,14 +247,18 @@ fn index(r: *Recording) !void {
var syscalls: std.ArrayList(Syscall) = .empty;
var marks: std.ArrayList(Mark) = .empty;
var allocations: std.ArrayList(Born) = .empty;
- var registers: std.ArrayList(u32) = .empty;
+ var registers: std.ArrayList(zt.Regs) = .empty;
var writes: std.ArrayList(Span) = .empty;
var write_ends: std.ArrayList(u32) = .empty;
+ var stores: std.ArrayList(Span) = .empty;
+ var store_ends: std.ArrayList(u32) = .empty;
var reads: std.ArrayList(Span) = .empty;
var read_ends: std.ArrayList(u32) = .empty;
var touch_list: std.ArrayList([2]?Touch) = .empty;
+ var locals: std.ArrayList(Declared) = .empty;
+ var globals: std.ArrayList(Span) = .empty;
// What the instruction at a stop is about to read is read by the step after it.
- var pending_reads: [2]?Touch = .{ null, null };
+ var pending: [2]?Touch = .{ null, null };
var branch_list: std.ArrayList(?Branch) = .empty;
var code_lines: std.AutoHashMapUnmanaged(u64, u32) = .empty;
defer code_lines.deinit(gpa);
@@ -274,6 +288,7 @@ fn index(r: *Recording) !void {
var line_at: ?u64 = null;
var line_file: ?u64 = null;
var stepped = false;
+ var broke = false;
var takes_nothing = false;
// An instrumented program's own events are drained before the
// debugger reports its stop: what follows its line is the debugger's.
@@ -281,7 +296,7 @@ fn index(r: *Recording) !void {
var touched: [2]?Touch = .{ null, null };
var branched: ?Branch = null;
snapshots.clearRetainingCapacity();
- for (pending_reads) |p| if (p) |read_by| if (read_by.how & 1 != 0) try reads.append(arena, .{ .addr = read_by.addr, .len = read_by.len });
+ for (pending) |p| if (p) |read_by| if (read_by.how & 1 != 0) try reads.append(arena, .{ .addr = read_by.addr, .len = read_by.len });
while (events.next()) |item| {
const ev = item.ev;
count += 1;
@@ -315,14 +330,17 @@ fn index(r: *Recording) !void {
try snapshots.append(gpa, !told or debugger_spoke);
},
.mem_read => if (ev.a[1] > 0) try reads.append(arena, .{ .addr = ev.a[0], .len = ev.a[1] }),
- .variable => if (open_calls.getLastOrNull()) |c| {
+ .variable => {
+ if ((zt.telescope.region(m, ev.a[0]) catch .none) == .stack) try locals.append(arena, .{ .moment = i, .addr = ev.a[0] }) else try globals.append(arena, .{ .addr = ev.a[0], .len = ev.a[1] });
// The first variable of a function that takes something is what it was given.
- const takes = for (r.functions) |f| {
- if (std.mem.eql(u8, f.name, r.name(calls.items[c].function))) break f.takes;
- } else true;
- if (takes and calls.items[c].parameter == null and ev.a[1] <= 8) {
- calls.items[c].parameter = .{ .addr = ev.a[0], .len = ev.a[1] };
- calls.items[c].parameter_name = ev.a[2];
+ if (open_calls.getLastOrNull()) |c| {
+ const takes = for (r.functions) |f| {
+ if (std.mem.eql(u8, f.name, r.name(calls.items[c].function))) break f.takes;
+ } else true;
+ if (takes and calls.items[c].parameter == null and ev.a[1] <= 8) {
+ calls.items[c].parameter = .{ .addr = ev.a[0], .len = ev.a[1] };
+ calls.items[c].parameter_name = ev.a[2];
+ }
}
},
.line => {
@@ -331,7 +349,11 @@ fn index(r: *Recording) !void {
// The pass counts its strings from 1; the debugger's ids are hashes with the top bit set.
if (ev.a[0] >> 63 != 0) debugger_spoke = true;
},
- .step, .breakpoint => stepped = true,
+ .step => stepped = true,
+ .breakpoint => {
+ stepped = true;
+ broke = true;
+ },
.touch => {
const slot: usize = if (touched[0] == null) 0 else 1;
if (touched[slot] == null) touched[slot] = .{ .addr = ev.a[0], .len = ev.a[1], .how = @intCast(ev.aux & 3) };
@@ -350,6 +372,7 @@ fn index(r: *Recording) !void {
// stores: bytes seen for the first time were not written by this
// step, unless it pushed them (the stack pointer went down a word).
var kept = first_write;
+ var changed_by_store = false;
for (writes.items[first_write..], snapshots.items) |span, snapshot| {
var fresh = true;
for (0..span.len) |b| {
@@ -364,13 +387,27 @@ fn index(r: *Recording) !void {
const pushed = regs != null and before != null and regs.?.rsp + 8 == before.?.rsp and span.addr <= regs.?.rsp and span.addr + span.len >= regs.?.rsp + 8;
keep = if (pushed) .{ .addr = regs.?.rsp, .len = 8 } else null;
}
+ // The store the instruction made says it to the element: below.
+ if (!told and stepped and stored(pending, span)) {
+ keep = null;
+ changed_by_store = true;
+ }
if (keep) |span_kept| {
writes.items[kept] = span_kept;
kept += 1;
}
}
writes.shrinkRetainingCapacity(kept);
+ // What the instruction at the stop before said it would store, it
+ // stored, the bytes it named: a write where the value changed (a
+ // debugger sees words change, the instruction says which element);
+ // a store all the same, even of the value that was there.
+ if (!told and stepped) for (pending) |p| if (p) |w| if (w.how & 2 != 0) {
+ try stores.append(arena, .{ .addr = w.addr, .len = w.len });
+ if (changed_by_store) try writes.append(arena, .{ .addr = w.addr, .len = w.len });
+ };
try write_ends.append(arena, @intCast(writes.items.len));
+ try store_ends.append(arena, @intCast(stores.items.len));
try read_ends.append(arena, @intCast(reads.items.len));
const line = (try m.line(r.tid)) orelse store.Line{};
try lines.append(arena, line);
@@ -378,10 +415,10 @@ fn index(r: *Recording) !void {
try own.append(arena, if (ours) line.line else if (own.items.len > 0) own.items[own.items.len - 1] else 0);
try reached.append(arena, ours and line_file != null);
try touch_list.append(arena, touched);
- pending_reads = touched;
+ pending = touched;
try branch_list.append(arena, branched);
if (ours and regs != null) try code_lines.put(gpa, regs.?.rip, line.line);
- try registers.append(arena, if (regs != null and before != null) changedRegisters(before.?, regs.?) else 0);
+ try registers.append(arena, regs orelse before orelse .{});
if (!told and stepped and regs != null and before != null) {
const now = regs.?;
@@ -407,6 +444,19 @@ fn index(r: *Recording) !void {
};
}
}
+ // A recording that begins inside a call (`record --from`): the call
+ // it first stops in was made before it, and is open.
+ if (!told and broke and ours and calls.items.len == 0) if (regs) |now| {
+ var found: [2]zt.Debugger.Frame = undefined;
+ const frames = zt.telescope.frames(m, &now, &found) catch found[0..0];
+ if (frames.len == 2 and frames[0].high > frames[0].low) {
+ const function = r.functionAt(line.line);
+ takes_nothing = function != null and !function.?.takes;
+ try calls.append(arena, .{ .function = try r.intern(if (function) |fun| fun.name else "?"), .parent = null, .depth = 0, .sp = frames[0].high - 8, .enter = i });
+ try open_calls.append(gpa, 0);
+ try derived.append(gpa, frames[1].pc);
+ }
+ };
if (regs) |g| before = g;
try depths.append(arena, @intCast(open_calls.items.len));
@@ -445,6 +495,7 @@ fn index(r: *Recording) !void {
r.allocations = allocations.items;
r.registers = registers.items;
r.write_spans = .{ .all = writes.items, .ends = write_ends.items };
+ r.store_spans = .{ .all = stores.items, .ends = store_ends.items };
r.insn_touches = touch_list.items;
r.insn_branches = branch_list.items;
r.code_lines = try arena.alloc(CodeLine, code_lines.count());
@@ -457,6 +508,8 @@ fn index(r: *Recording) !void {
}
}.less);
r.read_spans = .{ .all = reads.items, .ends = read_ends.items };
+ r.locals = locals.items;
+ r.globals = globals.items;
}
/// A string id for `text`, for names the recording did not define itself.
@@ -471,6 +524,8 @@ pub const Function = struct {
/// Whether it has parameters: `main(void)` has none; and how many.
takes: bool,
params: usize = 0,
+ /// Its first parameter's name ("" when it takes none).
+ param: []const u8 = "",
/// Its declaration's first line (from 1) and last.
first: u32,
last: u32,
@@ -490,7 +545,10 @@ pub fn outline(arena: std.mem.Allocator, source: []const u8, file: []const u8) !
if (from == paren) continue;
const close = std.mem.indexOfScalarPos(u8, header, paren, ')') orelse header.len;
const params = std.mem.trim(u8, header[paren + 1 .. close], " ");
- try found.append(arena, .{ .name = header[from..paren], .takes = params.len > 0 and !std.mem.eql(u8, params, "void"), .params = if (params.len > 0 and !std.mem.eql(u8, params, "void")) std.mem.count(u8, params, ",") + 1 else 0, .first = @intCast(d.start_line + 1), .last = @intCast(d.end_line + 1) });
+ const first_param = std.mem.trim(u8, params[0 .. std.mem.indexOfScalar(u8, params, ',') orelse params.len], " ");
+ var name_from = first_param.len;
+ while (name_from > 0 and (std.ascii.isAlphanumeric(first_param[name_from - 1]) or first_param[name_from - 1] == '_')) name_from -= 1;
+ try found.append(arena, .{ .name = header[from..paren], .takes = params.len > 0 and !std.mem.eql(u8, params, "void"), .params = if (params.len > 0 and !std.mem.eql(u8, params, "void")) std.mem.count(u8, params, ",") + 1 else 0, .param = first_param[name_from..], .first = @intCast(d.start_line + 1), .last = @intCast(d.end_line + 1) });
}
return found.items;
}
@@ -531,8 +589,7 @@ pub fn moment(r: *const Recording, i: u64) Moment {
/// Register `reg` of the thread shown at moment `i`; 0 when the recording
/// has no registers there.
pub fn register(r: *const Recording, i: u64, reg: []const u8) u64 {
- const regs = (r.moment(i).regs(r.tid) catch null) orelse return 0;
- return regs.named(reg) orelse 0;
+ return r.registers[@min(i, r.end())].named(reg) orelse 0;
}
/// A string id's text; "?" for one the recording never defined.
@@ -572,7 +629,17 @@ pub fn resolve(r: *const Recording, scratch: std.mem.Allocator, t: types.Type) ?
/// began: until then its bytes are whatever that stretch of stack held
/// before, and a picture should not show them as its value.
pub fn assigned(r: *const Recording, v: Variable, i: u64) bool {
- if (v.depth == 0) return true;
+ if (v.depth == 0) {
+ // A recording that tells no calls: a local is its value once
+ // written after it was declared; a global always is.
+ var k = r.locals.len;
+ while (k > 0) {
+ k -= 1;
+ const d = r.locals[k];
+ if (d.moment <= i and d.addr == v.addr) return touches(r.written(d.moment, i), v.addr, v.size) or touches(r.store_spans.of(d.moment, i), v.addr, v.size);
+ }
+ return true;
+ }
var enter: u64 = 0;
for (r.calls) |c| {
if (c.enter > i) break;
@@ -589,6 +656,32 @@ pub fn identity(r: *const Recording, m: Moment, addr: u64) ?usize {
return null;
}
+/// What file descriptor `fd` is open on at moment `i`, as the `value`
+/// class `fd` says it: the path the call that returned it was given,
+/// quoted; the three a program starts with by name; "" when not known.
+pub fn openOn(r: *const Recording, scratch: std.mem.Allocator, fd: u64, i: u64) []const u8 {
+ var on: []const u8 = switch (fd) {
+ 0 => "stdin",
+ 1 => "stdout",
+ 2 => "stderr",
+ else => "",
+ };
+ const SYS = std.os.linux.SYS;
+ for (r.syscalls) |s| {
+ if (s.enter >= i) break;
+ switch (std.enums.fromInt(SYS, s.nr) orelse continue) {
+ .open, .openat, .creat => if (s.exit != null and s.exit.? <= i and s.result == fd) {
+ on = if (s.text.len > 0) std.fmt.allocPrint(scratch, "\"{s}\"", .{std.fs.path.basename(s.text)}) catch "" else "";
+ },
+ .close => if (s.args[0] == fd) {
+ on = "";
+ },
+ else => {},
+ }
+ }
+ return on;
+}
+
/// The calls open at moment `i`, outermost first, in `scratch`.
/// shortcut: looks at every call made by then; a recording of a million calls wants each call's stack kept as a chain of parents.
pub fn stack(r: *const Recording, scratch: std.mem.Allocator, i: u64) []const Call {
@@ -676,13 +769,26 @@ pub fn read(r: *const Recording, from: u64, to: u64) []const Span {
return r.read_spans.of(from, to);
}
-/// A bit for each register of `Regs.names` they changed.
+/// A bit for each register of `Regs.names` that is not what it was:
+/// a register a step changed and put back (a call's rsp) is not changed.
pub fn registersChanged(r: *const Recording, from: u64, to: u64) u32 {
- var mask: u32 = 0;
- if (to < r.registers.len and from < to) for (r.registers[from + 1 .. to + 1]) |m| {
- mask |= m;
- };
- return mask;
+ if (to >= r.registers.len or from >= to) return 0;
+ return changedRegisters(r.registers[from], r.registers[to]);
+}
+
+/// Whether bytes `span` are drawn somewhere for the step from `from` to
+/// `to`: in the stack's frame round either stop's rsp and rbp, in an
+/// allocation, or in a global (an array's cells). Elsewhere (the library's
+/// own memory) a step's memory level has nothing to show.
+pub fn drawn(r: *const Recording, span: Span, from: u64, to: u64) bool {
+ for ([_]u64{ from, to }) |i| {
+ const regs = r.registers[@min(i, r.end())];
+ const low = regs.rsp -| 8;
+ const high = @max(regs.rbp, regs.rsp) + 16 + 8 * 8;
+ if (span.addr < high and span.addr + span.len > low) return true;
+ }
+ for (r.allocations) |a| if (span.addr < a.ptr + a.size and span.addr + span.len > a.ptr -| 16) return true;
+ return touches(r.globals, span.addr, span.len);
}
pub fn touches(list: []const Span, addr: u64, size: u64) bool {
@@ -690,6 +796,12 @@ pub fn touches(list: []const Span, addr: u64, size: u64) bool {
return false;
}
+/// Whether one of `by` (an instruction's touches) stores into `span`.
+fn stored(by: [2]?Touch, span: Span) bool {
+ for (by) |p| if (p) |w| if (w.how & 2 != 0 and w.addr < span.addr + span.len and w.addr + w.len > span.addr) return true;
+ return false;
+}
+
/// A bit for each register of `Regs.names` that differs between `a` and `b`.
pub fn changedRegisters(a: zt.Regs, b: zt.Regs) u32 {
var mask: u32 = 0;