summaryrefslogtreecommitdiff
path: root/src/trace/Debugger.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/trace/Debugger.zig')
-rw-r--r--src/trace/Debugger.zig52
1 files changed, 40 insertions, 12 deletions
diff --git a/src/trace/Debugger.zig b/src/trace/Debugger.zig
index f4f945b..886b0fc 100644
--- a/src/trace/Debugger.zig
+++ b/src/trace/Debugger.zig
@@ -219,9 +219,28 @@ pub fn cont(d: *Debugger) !Stop {
return d.report(try d.run(d.free()));
}
-/// One instruction.
+/// One instruction; a call or jump into the vDSO runs to its return, as
+/// one (`stepOne`).
pub fn stepi(d: *Debugger) !Stop {
- return d.report(try d.run(P.SINGLESTEP));
+ return d.report(try d.stepOne());
+}
+
+/// One instruction, but one that enters the vDSO (the kernel's code mapped
+/// into the process: `clock_gettime`, `gettimeofday`) from outside runs it
+/// through to where it returns, the return address on top of the stack:
+/// its loops retry while the kernel's time data changes under them, which
+/// a stop at each instruction makes them do for as long as stops are slow.
+fn stepOne(d: *Debugger) !Stop {
+ const from = d.regs.rip;
+ const stop = try d.run(P.SINGLESTEP);
+ if (stop != .step or !d.inVdso(d.regs.rip) or d.inVdso(from)) return stop;
+ var word: [8]u8 = undefined;
+ if (d.read(d.regs.rsp, &word) != 8) return stop;
+ return d.runTo(std.mem.readInt(u64, &word, .little), d.regs.rsp);
+}
+
+fn inVdso(d: *const Debugger, addr: u64) bool {
+ return if (d.syms.mappingAt(addr)) |m| std.mem.eql(u8, m.name, "[vdso]") else false;
}
/// To the next source line: instructions until the line is another, a call
@@ -231,7 +250,7 @@ pub fn step(d: *Debugger) !Stop {
const tid = d.proc.tid;
while (true) {
const before = d.regs;
- var stop = try d.run(P.SINGLESTEP);
+ var stop = try d.stepOne();
if (stop == .step and d.proc.tid == tid) {
if (d.lineAt(d.regs.rip)) |here| {
if (from == null or from.?.key != here.key or from.?.line != here.line) return d.report(.step);
@@ -538,6 +557,8 @@ fn emitCode(d: *Debugger) !void {
const target: ?u64 = if (from) |addr| (if (d.read(addr, &word) == 8) std.mem.readInt(u64, &word, .little) else null) else b.target;
if (b.kind != 0) if (target) |to| {
try d.nameAddress(to);
+ // Through memory: the slot it reads, where it has a name ("open@got").
+ if (b.indirect != 0 and b.kind != 3) if (from) |slot| if (d.syms.symbolAt(slot) != null) try d.nameAddress(slot);
try d.emit(.{ .kind = .branch, .aux = b.kind, .a = .{ to, b.taken, d.regs.rip, 0, 0, 0 } }, "");
};
}
@@ -643,12 +664,14 @@ fn emitTelescope(d: *Debugger) !void {
}
}
-/// The call that returns to `ret`, and the instruction there, recorded as
-/// instructions: an outer frame is on its call's line, `back` from `ret`.
+/// The call that returns to `ret`, the instruction before it and the one
+/// at `ret`, recorded as instructions, once: a caller's rows in a descent,
+/// and an outer frame is on its call's line, `back` from `ret`.
fn emitCall(d: *Debugger, ret: u64) !void {
const insnAt = d.disasm orelse return;
- if (d.code_len.contains(ret)) return;
- const sym = d.syms.symbolAt(ret) orelse return;
+ if ((try d.described.getOrPut(d.gpa, event.codeId(ret))).found_existing) return;
+ // Where its function begins: its symbol's, else its call frame information's (a stripped library's).
+ const sym = d.syms.symbolAt(ret) orelse if (d.syms.functionAt(ret -% 1)) |f| Symbols.Symbol{ .name = "", .addr = f.start, .size = f.len } else return;
if (sym.size == 0 or sym.size > 1 << 16 or ret == sym.addr) return;
const starts = try d.instructions(sym, insnAt);
const k = std.sort.binarySearch(u32, starts, @as(u32, @intCast(ret - sym.addr)), struct {
@@ -657,8 +680,7 @@ fn emitCall(d: *Debugger, ret: u64) !void {
}
}.order) orelse return;
if (k == 0) return;
- _ = try d.emitInstruction(insnAt, sym.addr + starts[k - 1], if (k > 1) @intCast(starts[k - 1] - starts[k - 2]) else 0);
- _ = try d.emitInstruction(insnAt, ret, @intCast(starts[k] - starts[k - 1]));
+ for (k -| 2..k + 1) |n| _ = try d.emitInstruction(insnAt, sym.addr + starts[n], if (n > 0) @intCast(starts[n] - starts[n - 1]) else 0);
}
/// Follows `value` as a pointer: a pointer into code gets its name and
@@ -678,12 +700,18 @@ fn chase(d: *Debugger, value: u64) !void {
}
}
-/// The string whose id is `addr`: its name ("main+4"), recorded once.
+/// The string whose id is `addr`: its name ("main+4"), recorded once. An
+/// address in a mapping not read yet (the syscalls that made it not
+/// followed) has its mappings read first, and one with no name is tried
+/// again the next time.
fn nameAddress(d: *Debugger, addr: u64) !void {
- if ((try d.described.getOrPut(d.gpa, addr)).found_existing) return;
+ if (d.described.contains(addr)) return;
+ d.know(addr);
var buf: [256]u8 = undefined;
var w: std.Io.Writer = .fixed(&buf);
- if (d.syms.label(&w, addr) catch false) try d.emit(.{ .kind = .string, .a = .{ addr, 0, 0, 0, 0, 0 } }, w.buffered());
+ if (!(d.syms.label(&w, addr) catch false)) return;
+ try d.described.put(d.gpa, addr, {});
+ try d.emit(.{ .kind = .string, .a = .{ addr, 0, 0, 0, 0, 0 } }, w.buffered());
}
fn emitStop(d: *Debugger, stop: Stop) !void {