summaryrefslogtreecommitdiff
path: root/anim/src/disasm.zig
diff options
context:
space:
mode:
Diffstat (limited to 'anim/src/disasm.zig')
-rw-r--r--anim/src/disasm.zig717
1 files changed, 608 insertions, 109 deletions
diff --git a/anim/src/disasm.zig b/anim/src/disasm.zig
index 7f17ed6..0b6f931 100644
--- a/anim/src/disasm.zig
+++ b/anim/src/disasm.zig
@@ -41,8 +41,18 @@ pub const Insn = struct {
/// A direct call's callee's parameter count.
params: ?u8 = null,
+ /// Its mnemonic, with a prefix that is part of it (`rep stosq`).
pub fn mnemonic(i: Insn) []const u8 {
- return i.text[0 .. std.mem.indexOfScalar(u8, i.text, ' ') orelse i.text.len];
+ const first = std.mem.indexOfScalar(u8, i.text, ' ') orelse return i.text;
+ for ([_][]const u8{ "rep", "repe", "repz", "repne", "repnz", "lock", "notrack", "bnd" }) |prefix| if (std.mem.eql(u8, i.text[0..first], prefix)) {
+ return i.text[0 .. std.mem.indexOfScalarPos(u8, i.text, first + 1, ' ') orelse i.text.len];
+ };
+ return i.text[0..first];
+ }
+
+ /// Padding, which touches nothing: drawn faint.
+ pub fn padding(i: Insn) bool {
+ return std.mem.startsWith(u8, i.mnemonic(), "nop") or std.mem.eql(u8, i.mnemonic(), "endbr64");
}
pub fn operands(i: Insn) []const u8 {
@@ -51,9 +61,11 @@ pub const Insn = struct {
};
/// The window at a moment: the instructions, and which is the pc's.
-const Listing = struct { rows: []Insn, pc: usize };
+pub const Listing = struct { rows: []Insn, pc: usize };
pub const Disasm = struct {
+ /// An instruction, as a row draws it.
+ pub const Row = Insn;
cursor: cursors.Cursor,
stage: *const Stage,
focus: bool = false,
@@ -171,6 +183,9 @@ pub const Disasm = struct {
var lanes: [2]?f32 = .{ null, null };
// A call's arguments hang in the annotation column of the rows under it.
var covered: usize = 0;
+ // What the window holds: a jump out of it says where it goes.
+ const window = [2]u64{ if (merged.len > 0) merged[0].addr else 0, if (merged.len > 0) merged[merged.len - 1].addr else 0 };
+ const echo = jumpEcho(now, base);
for (merged, 0..) |row, j| {
const y = top + (@as(f32, @floatFromInt(j)) - scroll) * m.row;
const line = if (row.outside) null else row.line;
@@ -188,7 +203,7 @@ pub const Disasm = struct {
const is_pc = row.addr == pc[if (going >= 0.5) 1 else 0];
const was = if (is_pc) null else ran[j];
if (was) |r| lit.trail(c.mark, y, r.k);
- const hangs = d.insn(lit, now, row, y, box.w, widen, line, line != last_line, current_line, lead, if (is_pc) .current else if (was) |r| .{ .ran = r } else .ahead, base, covered > 0);
+ const hangs = d.insn(lit, now, row, y, box.w, widen, line, line != last_line, current_line, lead, if (is_pc) .current else if (was) |r| .{ .ran = r } else .ahead, base, covered > 0, window, echo);
covered = @max(covered -| 1, hangs);
last_line = if (above_body) null else line;
if (jumped == row.addr and !is_pc) lanes[0] = y;
@@ -205,9 +220,16 @@ pub const Disasm = struct {
context.veiled(u, box, now.veil);
}
- const State = union(enum) { current, ran: Ran, ahead };
+ pub const State = union(enum) {
+ current,
+ ran: Ran,
+ ahead,
+ /// A call whose callee's window is open under it (a `descent`): the
+ /// moment it was made.
+ waiting: u64,
+ };
/// A row that ran `k` steps ago (0 newest), last at moment `at`.
- const Ran = struct { k: usize, at: u64 };
+ pub const Ran = struct { k: usize, at: u64 };
/// `insn`: an instruction and its annotation, pwndbg's way. Nothing is
/// cut that has room: the operands run on to where the annotation must
@@ -215,7 +237,7 @@ pub const Disasm = struct {
/// where the annotation carries the address they name. `covered`: a
/// call's arguments above hang in this row's annotation column. Returns
/// how many rows under it its own arguments hang in.
- fn insn(d: *const Disasm, at: ui.Ui, now: cursors.Now, row: Insn, y: f32, w: f32, widen: f32, line: ?u32, first_of_line: bool, current_line: u32, lead: usize, state: State, base: usize, covered: bool) usize {
+ pub fn insn(d: *const Disasm, at: ui.Ui, now: cursors.Now, row: Insn, y: f32, w: f32, widen: f32, line: ?u32, first_of_line: bool, current_line: u32, lead: usize, state: State, base: usize, covered: bool, window: [2]u64, echo: ?Echo) usize {
const rec = d.cursor.rec;
const base_y = rows.baseline(y);
const code_ink = theme.color.region.code_;
@@ -228,8 +250,9 @@ pub const Disasm = struct {
_ = at.address(c.address, base_y, row.addr, .{ .ink = ui.mix(code_ink, theme.color.page, theme.metric.context.lead_alpha) });
u.text(.mono, size, c.mnemonic, base_y, row.mnemonic(), t.faint);
const name = if (rec.strings.get(row.addr)) |n| n[0 .. std.mem.lastIndexOfScalar(u8, n, '+') orelse n.len] else "";
- const x = if (name.len > 0) annotationX(operandsWidth(row, row.operands()), room, @as(f32, @floatFromInt(name.len)) * adv) else room + gap;
- u.text(.mono, size, c.operands, base_y, rows.fitted(u, row.operands(), (if (covered) c.annotation else x) - gap - c.operands), t.faint);
+ const ops = shorn(u, row);
+ const x = if (name.len > 0) annotationX(operandsWidth(u, row, ops, ""), room, @as(f32, @floatFromInt(name.len)) * adv) else room + gap;
+ operands(u, row, ops, "", base_y, (if (covered) c.annotation else x) - gap - c.operands, t.faint);
u.text(.mono, size, x, base_y, name, t.faint);
return 0;
}
@@ -239,33 +262,31 @@ pub const Disasm = struct {
const now_line = l == current_line;
u.text(if (now_line) .mono_bold else .mono, size, c.line + 3 * adv - @as(f32, @floatFromInt(num.len)) * adv, base_y, num, if (now_line) theme.mark(.current).solid else t.faint);
};
- u.text(.mono_bold, size, c.mnemonic, base_y, row.mnemonic(), theme.color.code.keyword);
+ // Padding touches nothing: faint, with its operands.
+ const pad = row.padding();
+ u.text(.mono_bold, size, c.mnemonic, base_y, row.mnemonic(), if (pad) t.faint else theme.color.code.keyword);
// How wide the annotation is, drawn where nothing shows; then where it goes.
- const need = d.annotation(u.faded(0), now, row, y, c.annotation, std.math.inf(f32), state, base);
+ const need = d.annotation(u.faded(0), now, row, y, c.annotation, std.math.inf(f32), state, base, window, echo);
// When the operands and the annotation do not both fit: the
- // annotation moves left (never past its column), then a size word
- // a register already gives goes, then the operands give way.
- var ops = row.operands();
+ // 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 "";
var x = room + gap;
- if (need.drawn) {
- const wide = need.end - c.annotation;
- x = annotationX(operandsWidth(row, ops), room, wide);
- if (c.operands + operandsWidth(row, ops) + gap > x) if (lean(u, row)) |shorter| {
- ops = shorter;
- x = annotationX(operandsWidth(row, ops), room, wide);
- };
- }
- operands(u, row, ops, base_y, (if (covered) @min(x, c.annotation) else x) - gap - c.operands);
- return if (need.drawn) d.annotation(u, now, row, y, x, room, state, base).hangs else 0;
+ if (need.drawn) x = annotationX(operandsWidth(u, row, ops, stub), room, need.end - c.annotation);
+ operands(u, row, ops, stub, base_y, (if (covered) @min(x, c.annotation) else x) - gap - c.operands, if (pad) t.faint else theme.color.code.plain);
+ return if (need.drawn) d.annotation(u, now, row, y, x, room, state, base, window, echo).hangs else 0;
}
const Note = struct { drawn: bool = false, end: f32 = 0, hangs: usize = 0 };
+ /// The row that set the flags a conditional jump reads, while the jump
+ /// runs: its chips are framed as read with it (an `echo`).
+ const Echo = struct { addr: u64, shows: f32 };
/// The annotation: what it does, now, from `x`, cut where `room` ends.
/// What it left behind is shown only where the step ran this
/// instruction alone: a step by line runs others after it, and the
/// state after them is not its doing.
- fn annotation(d: *const Disasm, u: ui.Ui, now: cursors.Now, row: Insn, y: f32, x: f32, room: f32, state: State, base: usize) Note {
+ fn annotation(d: *const Disasm, u: ui.Ui, now: cursors.Now, row: Insn, y: f32, x: f32, room: f32, state: State, base: usize, window: [2]u64, echo: ?Echo) Note {
const rec = d.cursor.rec;
const base_y = rows.baseline(y);
const code_ink = theme.color.region.code_;
@@ -278,33 +299,30 @@ pub const Disasm = struct {
},
.ran => |r| .{ r.at, r.at + 1 },
.ahead => .{ now.stops[base], null },
+ .waiting => |w| .{ w, null },
};
if (after) |a| if (!alone(rec, moment, a, row)) {
after = null;
};
const branch = if (state == .ahead) null else rec.insn_branches[moment];
const touches = if (state == .ahead) [2]?Recording.Touch{ null, null } else rec.insn_touches[moment];
+ const mn = row.mnemonic();
+ const a: Say = .{ .u = u, .rec = rec, .y = y, .x = x, .room = room };
+ // Waiting on its callee: the call in C's form.
+ if (state == .waiting) if (branch) |b| return a.said(a.cForm(row, b.to, moment, null, a.room - a.x), t.primary);
+ // A system call: its name and number, its arguments hanging under it.
+ if (std.mem.eql(u8, mn, "syscall") and state != .ahead) return a.syscall(moment, state == .current);
if (branch) |b| switch (b.kind) {
.call => {
- const callee = rec.strings.get(b.to) orelse "";
- const callee_name = callee[0 .. std.mem.lastIndexOfScalar(u8, callee, '+') orelse callee.len];
- u.text(.mono, size, x, base_y, callee_name, t.bright);
- var note: Note = .{ .drawn = true, .end = x + @as(f32, @floatFromInt(callee_name.len)) * adv };
+ // Through memory or a register: where it went, and where that was read.
+ if (target(row) == null) return a.went(b.to, touches[0], moment);
+ // Once it has run: the call in C's form and its result.
+ if (state == .ran) if (returned(rec, row, moment, now.stops[base])) |back| {
+ return a.said(a.cForm(row, b.to, moment, rec.register(back, "rax"), a.room - a.x), t.primary);
+ };
+ 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) {
- // As many as the callee's prototype has (the debug info's, else the source's), three when neither says.
- const count: usize = row.params orelse for (rec.functions) |fun| {
- if (std.mem.eql(u8, fun.name, callee_name)) break fun.params;
- } else 3;
- const shown_moment = rec.moment(moment);
- const args = [_][]const u8{ "rdi", "rsi", "rdx", "rcx", "r8", "r9" };
- for (args[0..@min(count, 6)], 1..) |reg, k| {
- const ry = y + @as(f32, @floatFromInt(k)) * m.row;
- u.text(.mono, size, x, rows.baseline(ry), reg, t.dim);
- _ = rows.chain(u, x + 4 * adv, ry, shown_moment, rec.register(moment, reg), room, .{});
- }
- note.hangs = @min(count, 6);
- }
+ if (state == .current) note.hangs = a.arguments(row, b.to, moment);
return note;
},
.ret => {
@@ -312,32 +330,80 @@ pub const Disasm = struct {
return .{ .drawn = true, .end = u.address(x + 2 * adv, base_y, b.to, .{ .ink = ui.rgb(code_ink), .name = rec.strings.get(b.to) orelse "" }) };
},
.jump => {
- // A jump always taken says nothing; a conditional one, which way.
- if (std.mem.eql(u8, row.mnemonic(), "jmp")) return .{};
- const said = if (b.taken) "taken" else "not taken";
- u.text(.mono, size, x, base_y, said, if (b.taken) t.primary else t.dim);
- return .{ .drawn = true, .end = x + @as(f32, @floatFromInt(said.len)) * adv };
+ // Through memory or a register: where it goes. Straight: nothing to say.
+ if (std.mem.eql(u8, mn, "jmp")) return if (target(row) == null) a.went(b.to, touches[0], moment) else .{};
+ // A conditional: which way, and the flags it reads; taken out of the window, where to.
+ var end = a.word(x, if (b.taken) "taken" else "not taken", if (b.taken) t.primary else t.dim);
+ end = a.word(end + adv, "\u{00b7} reads", t.faint);
+ end = flags(u, end + adv, y, rec.register(moment, "eflags"), flagsRead(mn), 0);
+ if (b.taken and (b.to < window[0] or b.to > window[1])) {
+ end = a.word(end + adv, "\u{2192}", t.faint);
+ end = u.address(end + adv, base_y, b.to, .{ .ink = ui.rgb(code_ink), .name = ui.symbol(u, rec.strings.get(b.to) orelse "") });
+ }
+ return .{ .drawn = true, .end = end };
},
.none => {},
};
- if (std.mem.eql(u8, row.mnemonic(), "syscall") and state != .ahead) {
- const nr = rec.register(moment, "rax");
- const name = zt.syscalls.name(nr) orelse "syscall";
- u.text(.mono, size, x, base_y, name, t.bright);
- const names = zt.syscalls.names(nr);
- const carriers = [_][]const u8{ "rdi", "rsi", "rdx" };
- const n = @min(names.len, 3);
- if (state == .current) for (names[0..n], carriers[0..n], 1..) |arg, reg, k| {
- const ry = y + @as(f32, @floatFromInt(k)) * m.row;
- u.text(.mono, size, x, rows.baseline(ry), arg, t.dim);
- const ax = x + @as(f32, @floatFromInt(arg.len + 1)) * adv;
- const value = rec.register(moment, reg);
- // A descriptor is the `value` class `fd`: what it is open on.
- if (std.mem.endsWith(u8, arg, "fd")) {
- _ = u.typed(ax, rows.baseline(ry), value, .{ .fd = rec.openOn(u.f.scratch, value, moment) }, .{});
- } else _ = rows.chain(u, ax, ry, rec.moment(moment), value, room, .{});
+ if (state == .ahead) {
+ // Only what is static: a direct call's callee; a jump through the PLT's slot.
+ if (std.mem.eql(u8, mn, "call")) if (target(row)) |to| if (rec.strings.get(to) != null) return a.callee(to, moment);
+ if (std.mem.eql(u8, mn, "jmp")) if (ripSlot(row)) |slot| if ((zt.telescope.got(rec.moment(moment), slot) catch null)) |held| return a.went(held.value, .{ .addr = slot, .len = 8, .how = 1 }, moment);
+ return .{};
+ }
+ // A compare: the two values, then (once it has run) the flags it leaves.
+ if (std.mem.eql(u8, mn, "cmp") or std.mem.eql(u8, mn, "test")) {
+ const left = a.compared(row, moment, touches[0]);
+ var end = a.word(x, left[0], t.primary);
+ end = a.word(end, " : ", t.faint);
+ end = a.word(end, left[1], t.primary);
+ const left_at: ?u64 = switch (state) {
+ .ran => after,
+ .current => if (after != null and now.landed(.cpu, 0)) after else null,
+ .ahead, .waiting => null,
};
- return .{ .drawn = true, .end = x + @as(f32, @floatFromInt(name.len)) * adv, .hangs = if (state == .current) n else 0 };
+ if (left_at) |l| {
+ var buf: [256]u8 = undefined;
+ const next = rec.instruction(moment, row.addr + row.len, &buf);
+ var mask = if (next) |n| flagsRead((Insn{ .addr = 0, .len = 0, .text = n.text }).mnemonic()) else 0;
+ if (mask == 0) mask = flag_bits.cf | flag_bits.zf | flag_bits.sf | flag_bits.of;
+ end = flags(u, end + 2 * adv, y, rec.register(l, "eflags"), mask, if (echo) |e| if (e.addr == row.addr) e.shows else 0 else 0);
+ }
+ return .{ .drawn = true, .end = end };
+ }
+ // The rest is what it left behind, or where it reads: by what it is.
+ const value_at: ?u64 = switch (state) {
+ .ran => after,
+ .current => if (after != null and now.landed(.cpu, 0)) after.? else null,
+ .ahead, .waiting => null,
+ };
+ // A place the C library's layout names: the canary.
+ if (std.mem.indexOf(u8, row.text, "fs:[0x28]") != null) {
+ const end = a.word(x, if (x + 35 * adv <= room) "the stack's canary" else "canary", t.dim);
+ const word_ = if (touches[0]) |touch| Recording.word(rec.moment(value_at orelse moment), touch.addr, 8) catch null else null;
+ if (word_) |v| return .{ .drawn = true, .end = a.word(end + adv, u.print("{x}", .{v}), t.primary) };
+ u.unknown(.{ .x = end + adv, .y = y, .w = 24, .h = m.row });
+ return .{ .drawn = true, .end = end + adv + 24 };
+ }
+ // `lea`: `=` and what it made.
+ if (std.mem.eql(u8, mn, "lea")) {
+ const at = value_at orelse return .{};
+ const reg = written(row) orelse return .{};
+ const end = a.word(x, "=", t.faint);
+ return .{ .drawn = true, .end = rows.chain(u, end + adv, y, rec.moment(at), rec.register(at, reg), room, .{}).end };
+ }
+ // A `rep`: how many times, how wide each, and where it goes.
+ if (std.mem.startsWith(u8, mn, "rep")) {
+ const each: u8 = switch (mn[mn.len - 1]) {
+ 'b' => 1,
+ 'w' => 2,
+ 'd' => 4,
+ else => 8,
+ };
+ var end = a.word(x, "rcx", t.dim);
+ end = a.word(end + adv, u.print("{d}", .{rec.register(moment, "rcx")}), t.primary);
+ end = a.word(end + adv, u.print("\u{00b7} {d} bytes each", .{each}), t.faint);
+ end = a.word(end + adv, "rdi", t.dim);
+ return .{ .drawn = true, .end = rows.chain(u, end + adv, y, rec.moment(moment), rec.register(moment, "rdi"), room, .{}).end };
}
// Memory: a chain from the address it computes. Before the step,
// where it will look; in the step its first hop is read (with the
@@ -354,8 +420,8 @@ pub const Disasm = struct {
marks.read = 0;
marks.read_shows = now.reading(.memory, 0);
}
- if (writes) if (after) |a| {
- if (state == .ran or now.landed(.memory, 0)) shown = rec.moment(a);
+ if (writes) if (after) |aa| {
+ if (state == .ran or now.landed(.memory, 0)) shown = rec.moment(aa);
if (in_step) {
marks.changed = 1;
marks.changed_heat = now.written(touch.addr, touch.len, .memory, 0);
@@ -365,27 +431,350 @@ pub const Disasm = struct {
}
// Only a register: a small `reg` of what it left there.
const reg = written(row) orelse return .{};
- const value_at = switch (state) {
- .ran => after orelse return .{},
- .current => if (after != null and now.landed(.cpu, 0)) after.? else return .{},
- .ahead => return .{},
- };
- const value = rec.register(value_at, reg);
+ const at = value_at orelse return .{};
+ const value = rec.register(at, reg);
u.text(.mono, size, x, base_y, reg, t.dim);
- return .{ .drawn = true, .end = rows.chain(u, x + @as(f32, @floatFromInt(reg.len + 1)) * adv, y, rec.moment(value_at), value, room, .{}).end };
+ return .{ .drawn = true, .end = rows.chain(u, x + @as(f32, @floatFromInt(reg.len + 1)) * adv, y, rec.moment(at), value, room, .{}).end };
+ }
+};
+
+/// What an annotation says, from `x` on the row at `y`, cut where `room` ends.
+const Say = struct {
+ u: ui.Ui,
+ rec: *const Recording,
+ y: f32,
+ x: f32,
+ room: f32,
+
+ /// `text` at `x` in `ink`; where it ends.
+ fn word(a: Say, x: f32, text: []const u8, ink: u24) f32 {
+ a.u.text(.mono, size, x, rows.baseline(a.y), text, ink);
+ return x + @as(f32, @floatFromInt(std.unicode.utf8CountCodepoints(text) catch text.len)) * adv;
+ }
+
+ /// `text` from the annotation's place, cut at the room's end.
+ fn said(a: Say, text: []const u8, ink: u24) Disasm.Note {
+ return .{ .drawn = true, .end = a.word(a.x, if (std.math.isInf(a.room)) text else rows.fitted(a.u, text, a.room - a.x), ink) };
+ }
+
+ /// A function's name as a caller knows it: a PLT stub's is the
+ /// function it reaches (`open`), or the resolver while its slot is lazy.
+ fn functionName(a: Say, to: u64, moment: u64) []const u8 {
+ const name = ui.symbol(a.u, a.rec.strings.get(to) orelse return a.u.print("{x}", .{to}));
+ const bare = name[0 .. std.mem.lastIndexOfScalar(u8, name, '+') orelse name.len];
+ if (!std.mem.endsWith(u8, bare, "@plt")) return bare;
+ var buf: [256]u8 = undefined;
+ const jmp = a.rec.instruction(moment, to, &buf) orelse return bare[0 .. bare.len - 4];
+ if (ripSlot(.{ .addr = to, .len = jmp.len, .text = jmp.text })) |slot| if ((zt.telescope.got(a.rec.moment(moment), slot) catch null)) |held| {
+ if (held.lazy orelse false) return "the resolver";
+ };
+ return bare[0 .. bare.len - 4];
+ }
+
+ /// A direct call's callee, bright.
+ fn callee(a: Say, to: u64, moment: u64) Disasm.Note {
+ return .{ .drawn = true, .end = a.word(a.x, a.functionName(to, moment), t.bright) };
+ }
+
+ /// A call's arguments under it, a small `reg` a row: as many as its
+ /// prototype has (the debug info's, the source's, a system call's of
+ /// its name), three when none says. How many rows they take.
+ fn arguments(a: Say, row: Insn, to: u64, moment: u64) usize {
+ const name = a.functionName(to, moment);
+ const count = @min(row.params orelse for (a.rec.functions) |fun| {
+ if (std.mem.eql(u8, fun.name, name)) break fun.params;
+ } else argumentCount(a.rec, row, name) orelse 3, 6);
+ const shown = a.rec.moment(moment);
+ // Flags by name, where a system call of its name says which argument they are.
+ const nr: ?u64 = if (std.meta.stringToEnum(std.os.linux.SYS, name)) |sys| @intFromEnum(sys) else null;
+ const names: []const []const u8 = if (nr) |n| zt.syscalls.names(n) else &.{};
+ for (carriers[0..count], 1..) |reg, k| {
+ const ry = a.y + @as(f32, @floatFromInt(k)) * m.row;
+ a.u.text(.mono, size, a.x, rows.baseline(ry), reg, t.dim);
+ const v = a.rec.register(moment, reg);
+ if (k - 1 < names.len and std.mem.eql(u8, names[k - 1], "flags")) {
+ a.u.text(.mono, size, a.x + 4 * adv, rows.baseline(ry), openFlags(a.u, v), t.primary);
+ } else _ = rows.chain(a.u, a.x + 4 * adv, ry, shown, v, a.room, .{});
+ }
+ return count;
+ }
+
+ /// The call at `row` (to `to`, made at `moment`) in C's form, its
+ /// arguments as the source wrote that many and as the system call of its
+ /// name types them; with ` = result` when it has returned.
+ fn cForm(a: Say, row: Insn, to: u64, moment: u64, result: ?u64, width: f32) []const u8 {
+ const u = a.u;
+ const name = a.functionName(to, moment);
+ const nr: ?u64 = if (std.meta.stringToEnum(std.os.linux.SYS, name)) |sys| @intFromEnum(sys) else null;
+ const names: []const []const u8 = if (nr) |n| zt.syscalls.names(n) else &.{};
+ const count = @min(row.params orelse argumentCount(a.rec, row, name) orelse names.len, 6);
+ // Out of room the arguments go from the right, `…` for them; the result stays.
+ var shown = count;
+ while (true) : (shown -= 1) {
+ var out: []const u8 = u.print("{s}(", .{name});
+ for (carriers[0..shown], 0..) |reg, k| {
+ const v = a.rec.register(moment, reg);
+ out = u.print("{s}{s}{s}", .{ out, if (k > 0) ", " else "", argument(u, a.rec, moment, if (k < names.len) names[k] else "", v) });
+ }
+ if (shown < count) out = u.print("{s}{s}\u{2026}", .{ out, if (shown > 0) ", " else "" });
+ out = u.print("{s})", .{out});
+ if (result) |r| out = u.print("{s} = {d}", .{ out, @as(i64, @bitCast(r)) });
+ if (shown == 0 or @as(f32, @floatFromInt(std.unicode.utf8CountCodepoints(out) catch out.len)) * adv <= width) return out;
+ }
+ }
+
+ /// Where a call or a jump through memory or a register went: `→ addr
+ /// name`, then faint where it was read, `· read from open@got, 403fd8`.
+ /// Out of room the slot goes first, then the digits; the name stays.
+ fn went(a: Say, to: u64, slot: ?Recording.Touch, moment: u64) Disasm.Note {
+ const u = a.u;
+ const name = a.functionName(to, moment);
+ const from: []const u8 = if (slot) |s| blk: {
+ const named = ui.symbol(u, a.rec.strings.get(s.addr) orelse "");
+ break :blk u.print("\u{00b7} read from {s}{s}{x}", .{ named[0 .. std.mem.lastIndexOfScalar(u8, named, '+') orelse named.len], if (named.len > 0) ", " else "", s.addr });
+ } else "";
+ const digits_w = @as(f32, @floatFromInt(ui.digits(to) + 1)) * adv;
+ const name_w = @as(f32, @floatFromInt(name.len)) * adv;
+ const from_w = @as(f32, @floatFromInt(std.unicode.utf8CountCodepoints(from) catch from.len)) * adv;
+ const fits_all = a.x + 2 * adv + digits_w + name_w + adv + from_w <= a.room;
+ const fits_digits = a.x + 2 * adv + digits_w + name_w <= a.room;
+ var end = a.word(a.x, "\u{2192}", t.faint) + adv;
+ if (fits_digits) {
+ end = u.address(end, rows.baseline(a.y), to, .{ .ink = ui.rgb(theme.color.region.code_), .name = name });
+ } else end = a.word(end, name, t.primary);
+ if (fits_all and from.len > 0) end = a.word(end + adv, from, t.faint);
+ return .{ .drawn = true, .end = end };
+ }
+
+ /// The two values a compare compares, as its operands' size reads them.
+ fn compared(a: Say, row: Insn, moment: u64, touch: ?Recording.Touch) [2][]const u8 {
+ const ops = shorn(a.u, row);
+ var parts = std.mem.splitScalar(u8, ops.text, ',');
+ var operands_: [2][]const u8 = .{ "", "" };
+ for (&operands_) |*o| o.* = std.mem.trim(u8, parts.next() orelse "", " ");
+ // The size: a register's, else the width's, else a word's.
+ var bytes: u8 = if (ops.bytes > 0) ops.bytes else 8;
+ for (operands_) |o| if (registerSize(o)) |n| {
+ bytes = n;
+ };
+ var out: [2][]const u8 = undefined;
+ for (operands_, &out) |o, *v| {
+ const raw: ?u64 = if (std.mem.indexOfScalar(u8, o, '[') != null)
+ (if (touch) |tt| Recording.word(a.rec.moment(moment), tt.addr, @min(tt.len, 8)) catch null else null)
+ else if (full(o)) |reg|
+ a.rec.register(moment, reg)
+ else
+ parseImmediate(o);
+ v.* = if (raw) |r| number(a.u, r, bytes) else "..";
+ }
+ return out;
+ }
+
+ /// `syscall`: its name and number (`openat nr 257`); its arguments hang
+ /// under it, a register a row, each read as its name says.
+ fn syscall(a: Say, moment: u64, current: bool) Disasm.Note {
+ const u = a.u;
+ const nr = a.rec.register(moment, "rax");
+ var end = a.word(a.x, zt.syscalls.name(nr) orelse "syscall", t.bright);
+ end = a.word(end + adv, "nr", t.faint);
+ end = a.word(end + adv, u.print("{d}", .{nr}), t.primary);
+ const names = zt.syscalls.names(nr);
+ const n = @min(zt.syscalls.signature(nr).len, 6);
+ if (!current) return .{ .drawn = true, .end = end };
+ for (carriers_sys[0..n], 0..) |reg, k| {
+ const ry = a.y + @as(f32, @floatFromInt(k + 1)) * m.row;
+ u.text(.mono, size, a.x, rows.baseline(ry), reg, t.dim);
+ const v = a.rec.register(moment, reg);
+ const what = if (k < names.len) names[k] else "";
+ const ax = a.x + 4 * adv;
+ if (std.mem.eql(u8, what, "path") or std.mem.eql(u8, what, "buf")) {
+ _ = rows.chain(u, ax, ry, a.rec.moment(moment), v, a.room, .{});
+ } else if (std.mem.endsWith(u8, what, "fd") and v == fdcwd) {
+ // The value class `fd`: the number, and faint what it names.
+ u.text(.mono, size, ax, rows.baseline(ry), "-100", t.primary);
+ u.text(.mono, size, ax + 5 * adv, rows.baseline(ry), "AT_FDCWD", t.faint);
+ } else if (std.mem.endsWith(u8, what, "fd")) {
+ _ = u.typed(ax, rows.baseline(ry), v, .{ .fd = a.rec.openOn(u.f.scratch, v, moment) }, .{});
+ } else u.text(.mono, size, ax, rows.baseline(ry), argument(u, a.rec, moment, what, v), t.primary);
+ }
+ return .{ .drawn = true, .end = end, .hangs = n };
+ }
+};
+
+/// A call's argument registers, in order; a system call's.
+const carriers = [_][]const u8{ "rdi", "rsi", "rdx", "rcx", "r8", "r9" };
+const carriers_sys = [_][]const u8{ "rdi", "rsi", "rdx", "r10", "r8", "r9" };
+/// `AT_FDCWD`, as a register holds it.
+const fdcwd: u64 = @bitCast(@as(i64, -100));
+
+/// An argument's value as C would write it, by its name: a path as its
+/// string, flags by name, a descriptor and a count in decimal, a pointer as
+/// its address.
+pub fn argument(u: ui.Ui, rec: *const Recording, moment: u64, what: []const u8, v: u64) []const u8 {
+ if (std.mem.eql(u8, what, "path")) {
+ var links: [2]zt.telescope.Link = undefined;
+ var text: [48]u8 = undefined;
+ const chain = zt.telescope.chase(rec.moment(moment), v, &links, &text) catch &.{};
+ if (chain.len > 0 and chain[chain.len - 1].string) return u.print("\"{s}\"", .{chain[chain.len - 1].text});
+ }
+ if (std.mem.eql(u8, what, "flags")) return openFlags(u, v);
+ if (std.mem.endsWith(u8, what, "fd") and v == fdcwd) return "AT_FDCWD";
+ const signed: i64 = @bitCast(v);
+ if (signed > -4096 and signed < 0x10000) return u.print("{d}", .{signed});
+ return u.print("{x}", .{v});
+}
+
+/// `open`'s flags by name, `O_RDONLY`; bits no name covers as `0x` and their hex.
+fn openFlags(u: ui.Ui, v: u64) []const u8 {
+ var out: []const u8 = switch (v & 3) {
+ 0 => "O_RDONLY",
+ 1 => "O_WRONLY",
+ else => "O_RDWR",
+ };
+ var rest = v & ~@as(u64, 3);
+ for ([_]struct { []const u8, u64 }{ .{ "O_CREAT", 0o100 }, .{ "O_EXCL", 0o200 }, .{ "O_NOCTTY", 0o400 }, .{ "O_TRUNC", 0o1000 }, .{ "O_APPEND", 0o2000 }, .{ "O_NONBLOCK", 0o4000 }, .{ "O_DIRECTORY", 0o200000 }, .{ "O_NOFOLLOW", 0o400000 }, .{ "O_CLOEXEC", 0o2000000 } }) |f| if (rest & f[1] != 0) {
+ out = u.print("{s}|{s}", .{ out, f[0] });
+ rest &= ~f[1];
+ };
+ return if (rest != 0) u.print("{s} 0x{x}", .{ out, rest }) else out;
+}
+
+/// How many arguments the program's source gives `name` on the call's line.
+fn argumentCount(rec: *const Recording, row: Insn, name: []const u8) ?usize {
+ const line = row.line orelse return null;
+ var lines = std.mem.splitScalar(u8, rec.source, '\n');
+ var n: u32 = 1;
+ const text = while (lines.next()) |l| : (n += 1) {
+ if (n == line) break l;
+ } else return null;
+ const open = (std.mem.indexOf(u8, text, name) orelse return null) + name.len;
+ if (open >= text.len or text[open] != '(') return null;
+ var depth: usize = 0;
+ var count: usize = 0;
+ var any = false;
+ for (text[open + 1 ..]) |ch| switch (ch) {
+ '(' => depth += 1,
+ ')' => {
+ if (depth == 0) return if (any) count + 1 else 0;
+ depth -= 1;
+ },
+ ',' => if (depth == 0) {
+ count += 1;
+ },
+ ' ' => {},
+ else => any = true,
+ };
+ return null;
+}
+
+/// The moment a call made at `moment` from `row` came back to the row after
+/// it, at or before `until`.
+fn returned(rec: *const Recording, row: Insn, moment: u64, until: u64) ?u64 {
+ const sp = rec.register(moment, "rsp");
+ var i = moment + 1;
+ while (i <= until) : (i += 1) {
+ if (rec.register(i, "rip") == row.addr + row.len and rec.register(i, "rsp") == sp) return i;
}
+ return null;
+}
+
+/// The slot a `jmp` or `call` through `[rip + X]` reads.
+fn ripSlot(row: Insn) ?u64 {
+ const ops = row.operands();
+ const at = std.mem.indexOf(u8, ops, "[rip + 0x") orelse return null;
+ const close = std.mem.indexOfScalarPos(u8, ops, at, ']') orelse return null;
+ const disp = std.fmt.parseInt(u64, ops[at + 9 .. close], 16) catch return null;
+ return row.addr + row.len + disp;
+}
+
+/// An immediate operand's value.
+fn parseImmediate(o: []const u8) ?u64 {
+ const negative = std.mem.startsWith(u8, o, "-");
+ const digits_ = if (negative) o[1..] else o;
+ const v = (if (std.mem.startsWith(u8, digits_, "0x")) std.fmt.parseInt(u64, digits_[2..], 16) else std.fmt.parseInt(u64, digits_, 10)) catch return null;
+ return if (negative) 0 -% v else v;
+}
+
+/// `v` as a number `bytes` wide: signed and in decimal when small, else hex.
+fn number(u: ui.Ui, v: u64, bytes: u8) []const u8 {
+ const bits: u7 = @as(u7, @min(bytes, 8)) * 8;
+ const masked = if (bits == 64) v else v & ((@as(u64, 1) << @intCast(bits)) - 1);
+ const signed: i64 = if (bits == 64) @bitCast(masked) else @as(i64, @bitCast(masked << @intCast(64 - @as(u7, bits)))) >> @intCast(64 - @as(u7, bits));
+ if (signed > -0x10000 and signed < 0x10000) return u.print("{d}", .{signed});
+ return u.print("{x}", .{masked});
+}
+
+/// eflags' bits a reader meets.
+const flag_bits = struct {
+ const cf: u16 = 1 << 0;
+ const pf: u16 = 1 << 2;
+ const zf: u16 = 1 << 6;
+ const sf: u16 = 1 << 7;
+ const of: u16 = 1 << 11;
};
+/// The flags a conditional (`jcc`, `setcc`, `cmovcc`) reads; 0 for anything else.
+pub fn flagsRead(mn: []const u8) u16 {
+ const cond = if (std.mem.startsWith(u8, mn, "cmov")) mn[4..] else if (std.mem.startsWith(u8, mn, "set")) mn[3..] else if (mn.len > 1 and mn[0] == 'j' and !std.mem.eql(u8, mn, "jmp")) mn[1..] else return 0;
+ const f = flag_bits;
+ const table = [_]struct { []const u8, u16 }{
+ .{ "a", f.cf | f.zf }, .{ "nbe", f.cf | f.zf }, .{ "be", f.cf | f.zf }, .{ "na", f.cf | f.zf },
+ .{ "ae", f.cf }, .{ "nb", f.cf }, .{ "nc", f.cf }, .{ "b", f.cf },
+ .{ "c", f.cf }, .{ "nae", f.cf }, .{ "e", f.zf }, .{ "z", f.zf },
+ .{ "ne", f.zf }, .{ "nz", f.zf }, .{ "g", f.zf | f.sf | f.of }, .{ "nle", f.zf | f.sf | f.of },
+ .{ "le", f.zf | f.sf | f.of }, .{ "ng", f.zf | f.sf | f.of }, .{ "ge", f.sf | f.of }, .{ "nl", f.sf | f.of },
+ .{ "l", f.sf | f.of }, .{ "nge", f.sf | f.of }, .{ "o", f.of }, .{ "no", f.of },
+ .{ "s", f.sf }, .{ "ns", f.sf }, .{ "p", f.pf }, .{ "pe", f.pf },
+ .{ "np", f.pf }, .{ "po", f.pf },
+ };
+ for (table) |e| if (std.mem.eql(u8, cond, e[0])) return e[1];
+ return 0;
+}
+
+/// The flags of `mask`, as rip's row draws them: set, upper case on a
+/// chip; clear, lower case and dim; each framed as read by `read`. Where they end.
+fn flags(u: ui.Ui, x: f32, y: f32, eflags: u64, mask: u16, read: f32) f32 {
+ var at = x;
+ for (rows.flags) |flag| {
+ if (@as(u64, mask) >> flag.bit & 1 == 0) continue;
+ const chip: Rect = .{ .x = at, .y = y + 2, .w = theme.metric.flags.chip[0], .h = theme.metric.flags.chip[1] };
+ if (eflags >> flag.bit & 1 != 0) {
+ u.chip(chip);
+ u.text(.mono_bold, size, at + 4, rows.baseline(y), flag.name, t.bright);
+ } else u.text(.mono, size, at + 4, rows.baseline(y), u.print("{c}{c}", .{ std.ascii.toLower(flag.name[0]), std.ascii.toLower(flag.name[1]) }), t.dim);
+ if (read > 0) u.read(chip, read);
+ at += chip.w + 4;
+ }
+ return at - 4;
+}
+
+/// While a conditional jump runs (the mark on it, its step under way), the
+/// row that set the flags it reads: the instruction just before it ran.
+fn jumpEcho(now: cursors.Now, base: usize) ?Disasm.Echo {
+ if (base != 1 or now.resting()) return null;
+ const flags_ = readsFlags(now.rec, now.stops[1]);
+ if (flags_ == 0 or now.stops[1] == 0) return null;
+ return .{ .addr = now.rec.register(now.stops[1] - 1, "rip"), .shows = now.reading(.cpu, 0) };
+}
+
+/// The flags the instruction at moment `i`'s pc reads, if it is a conditional.
+pub fn readsFlags(rec: *const Recording, i: u64) u16 {
+ var buf: [256]u8 = undefined;
+ const pc = rec.register(i, "rip");
+ const here = rec.instruction(i, pc, &buf) orelse return 0;
+ return flagsRead((Insn{ .addr = pc, .len = here.len, .text = here.text }).mnemonic());
+}
+
/// The gap between the operands and the annotation: a character.
const gap = adv;
/// The runs of rows of one line, top and bottom of each, as the rows go by.
-const Runs = struct {
+pub const Runs = struct {
spans: [8][2]f32 = undefined,
n: usize = 0,
open: ?f32 = null,
- fn add(r: *Runs, on: bool, y: f32, end: f32) void {
+ pub fn add(r: *Runs, on: bool, y: f32, end: f32) void {
if (on and r.open == null) r.open = y;
if (!on) if (r.open) |y0| {
if (r.n < r.spans.len and end > y0) {
@@ -400,7 +789,7 @@ const Runs = struct {
/// The thread's runs, `p` of the way from the line the mark leaves to the
/// one it goes to: each slides to its partner (by order, the last of the
/// fewer standing in for the rest), as the source's bracket slides.
-fn threadRuns(u: ui.Ui, w: f32, runs: [2]Runs, p: f32) void {
+pub fn threadRuns(u: ui.Ui, w: f32, runs: [2]Runs, p: f32) void {
const from = runs[0];
const to = runs[1];
if (to.n == 0 or p >= 1 or from.n == 0) {
@@ -445,53 +834,147 @@ fn alone(rec: *const Recording, i: u64, after: u64, row: Insn) bool {
}
/// A jump's or a call's target, when the disassembler wrote it as one.
-fn target(row: Insn) ?u64 {
+pub fn target(row: Insn) ?u64 {
const ops = row.operands();
const mn = row.mnemonic();
if (!(mn[0] == 'j' or std.mem.eql(u8, mn, "call")) or !std.mem.startsWith(u8, ops, "0x")) return null;
return std.fmt.parseInt(u64, ops[2..], 16) catch null;
}
-/// How wide operands `ops` of `row` are, whole.
-fn operandsWidth(row: Insn, ops: []const u8) f32 {
- if (target(row)) |to| return @as(f32, @floatFromInt(ui.digits(to))) * adv;
- return @as(f32, @floatFromInt(ops.len)) * adv;
+/// An `insn` with no state and no annotation: its address, its mnemonic
+/// (faint for padding) and its operands as canim draws them, at `y` in `u`
+/// (the panel's origin). For the gallery's page of rows.
+pub fn plainRow(u: ui.Ui, row: Insn, y: f32) void {
+ const base_y = rows.baseline(y);
+ _ = u.address(c.address, base_y, row.addr, .{ .ink = ui.rgb(theme.color.region.code_) });
+ // A library's twelve digits move what is right of them, 12 a digit past seven.
+ const v = u.moved(@as(f32, @floatFromInt(@max(ui.digits(row.addr), 7) - 7)) * adv, 0);
+ const pad = row.padding();
+ v.text(.mono_bold, size, c.mnemonic, base_y, row.mnemonic(), if (pad) t.faint else theme.color.code.keyword);
+ operands(v, row, shorn(v, row), "", base_y, c.annotation - gap - c.operands, if (pad) t.faint else theme.color.code.plain);
}
-/// The operands without the size word of a memory operand whose size a
-/// register operand gives (`mov rax, [rbp - 0x28]`): nothing is lost.
-/// Null where there is none to drop.
-fn lean(u: ui.Ui, row: Insn) ?[]const u8 {
+/// Operands as canim draws them (design/README.md, `insn` and `width`):
+/// the disassembler's less every size word (`qword ptr `); and where no
+/// register outside the brackets has the access's size and the mnemonic
+/// does not fix it, how many bytes it touches (`bytes`), drawn as byte
+/// cells after the `]` that ends at `after`.
+const Operands = struct { text: []const u8, after: usize = 0, bytes: u8 = 0 };
+
+fn shorn(u: ui.Ui, row: Insn) Operands {
+ var ops = row.operands();
+ var bytes: u8 = 0;
+ while (std.mem.indexOf(u8, ops, " ptr ")) |ptr| {
+ var word = ptr;
+ while (word > 0 and ops[word - 1] != ' ' and ops[word - 1] != ',') word -= 1;
+ for ([_]struct { []const u8, u8 }{ .{ "byte", 1 }, .{ "word", 2 }, .{ "dword", 4 }, .{ "qword", 8 }, .{ "tbyte", 10 }, .{ "xmmword", 16 }, .{ "ymmword", 32 }, .{ "zmmword", 64 } }) |w| {
+ if (std.mem.eql(u8, ops[word..ptr], w[0])) bytes = w[1];
+ }
+ ops = u.print("{s}{s}", .{ ops[0..word], ops[ptr + 5 ..] });
+ }
+ const close = std.mem.indexOfScalar(u8, ops, ']') orelse return .{ .text = ops };
+ if (bytes == 0) return .{ .text = ops };
+ // Said already: by the mnemonic (a stack op, a branch through memory,
+ // what touches nothing, a string op's suffix, SSE's scalar ops), or by
+ // a register outside the brackets of the access's size.
const mn = row.mnemonic();
- // These widen or convert: the register does not give the memory's size.
- for ([_][]const u8{ "movzx", "movsx", "movsxd", "cvt" }) |w| if (std.mem.startsWith(u8, mn, w)) return null;
- const ops = row.operands();
- const ptr = std.mem.indexOf(u8, ops, " ptr ") orelse return null;
- var word = ptr;
- while (word > 0 and ops[word - 1] != ' ' and ops[word - 1] != ',') word -= 1;
- const comma = std.mem.indexOfScalar(u8, ops, ',') orelse return null;
- const other = std.mem.trim(u8, if (comma < word) ops[0..comma] else ops[comma + 1 ..], " ");
- if (full(other) == null) return null;
- return u.print("{s}{s}", .{ ops[0..word], ops[ptr + 5 ..] });
+ for ([_][]const u8{ "push", "pop", "call", "jmp", "lea", "nop", "rep" }) |says| if (std.mem.startsWith(u8, mn, says)) return .{ .text = ops };
+ if (mn.len == 0 or mn[0] == 'j') return .{ .text = ops };
+ var parts = std.mem.splitScalar(u8, ops, ',');
+ while (parts.next()) |part| {
+ const operand = std.mem.trim(u8, part, " ");
+ if (std.mem.indexOfScalar(u8, operand, '[') != null) continue;
+ const of = registerSize(operand) orelse continue;
+ if (of == bytes or of >= 16) return .{ .text = ops };
+ }
+ return .{ .text = ops, .after = close + 1, .bytes = bytes };
+}
+
+/// How many bytes register `name` is; null for anything else.
+fn registerSize(name: []const u8) ?u8 {
+ if (name.len < 2) return null;
+ for ([_]struct { []const u8, u8 }{ .{ "xmm", 16 }, .{ "ymm", 32 }, .{ "zmm", 64 } }) |v| if (std.mem.startsWith(u8, name, v[0])) return v[1];
+ if (full(name) == null and !(name.len == 3 and name[2] == 'l')) return null;
+ if (name[0] == 'r' and std.ascii.isDigit(name[1])) return switch (name[name.len - 1]) {
+ 'd' => 4,
+ 'w' => 2,
+ 'b' => 1,
+ else => 8,
+ };
+ if (name.len == 3) return switch (name[0]) {
+ 'r' => 8,
+ 'e' => 4,
+ else => 1, // sil, dil, bpl, spl
+ };
+ return if (name[1] == 'l' or name[1] == 'h') 1 else 2;
+}
+
+/// How wide `width`'s cells are for an access of `bytes`, with the gaps
+/// round them (3 after the `]`, 4 before what follows) and, past eight
+/// bytes, the count.
+fn cellsWidth(u: ui.Ui, bytes: u8) f32 {
+ if (bytes == 0) return 0;
+ const w = theme.metric.width;
+ const n: f32 = @floatFromInt(@min(bytes, 8));
+ const count: f32 = if (bytes > 8) u.width(.mono, size, u.print("{d}", .{bytes})) + w.after else 0;
+ return w.before + (n - 1) * w.pitch + w.cell[0] + w.after + count;
+}
+
+/// `width`: `bytes` byte cells at `x`, standing on the baseline; a count past eight.
+fn cells(u: ui.Ui, x: f32, base_y: f32, bytes: u8) void {
+ const w = theme.metric.width;
+ for (0..@min(bytes, 8)) |k| u.fill(.{ .x = x + w.before + @as(f32, @floatFromInt(k)) * w.pitch, .y = base_y - w.cell[1], .w = w.cell[0], .h = w.cell[1] }, t.dim);
+ if (bytes > 8) u.text(.mono, size, x + w.before + 7 * w.pitch + w.cell[0] + w.after, base_y, u.print("{d}", .{bytes}), t.faint);
+}
+
+/// 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];
+ return if (std.mem.endsWith(u8, stub, "@plt")) stub else "";
}
-/// The operands `ops`, in `width` units; a jump's or a call's target is
-/// an `address` in code's ink. Cut only at their far end, saying so, and
-/// never inside `[]`: a cut that would fall there falls before the `[`.
-fn operands(u: ui.Ui, row: Insn, ops: []const u8, base_y: f32, width: f32) void {
+/// 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;
+ return @as(f32, @floatFromInt(ops.text.len)) * adv + cellsWidth(u, ops.bytes);
+}
+
+/// The operands `ops`, in `width` units, in `ink`; a jump's or a call's
+/// target is an `address` in code's ink, a PLT stub's with its name. Cut
+/// only at their far end, saying so, and never inside `[]`: a cut that
+/// would fall there falls before the `[`.
+fn operands(u: ui.Ui, row: Insn, ops: Operands, stub: []const u8, base_y: f32, width: f32, ink: u24) void {
if (target(row)) |to| {
- _ = u.address(c.operands, base_y, to, .{ .ink = ui.rgb(theme.color.region.code_) });
+ _ = u.address(c.operands, base_y, to, .{ .ink = ui.rgb(theme.color.region.code_), .name = stub });
+ return;
+ }
+ const text = ops.text;
+ const extra = cellsWidth(u, ops.bytes);
+ const at_after = c.operands + @as(f32, @floatFromInt(ops.after)) * adv;
+ if (@as(f32, @floatFromInt(text.len)) * adv + extra <= width) {
+ if (ops.bytes == 0) return u.text(.mono, size, c.operands, base_y, text, ink);
+ u.text(.mono, size, c.operands, base_y, text[0..ops.after], ink);
+ cells(u, at_after, base_y, ops.bytes);
+ u.text(.mono, size, at_after + extra, base_y, text[ops.after..], ink);
return;
}
- const chars: usize = @intFromFloat(@max(width / adv, 1));
- if (ops.len <= chars) return u.text(.mono, size, c.operands, base_y, ops, theme.color.code.plain);
- var cut = chars - 1;
- if (std.mem.lastIndexOfScalar(u8, ops[0..cut], '[')) |open| {
- if (std.mem.indexOfScalarPos(u8, ops, open, ']') orelse ops.len >= cut) cut = open;
+ var chars: usize = @intFromFloat(@max(width / adv, 1));
+ if (ops.bytes > 0 and chars > ops.after) chars = @max(@as(usize, @intFromFloat(@max((width - extra) / adv, 1))), ops.after);
+ var cut = @min(chars - 1, text.len);
+ if (std.mem.lastIndexOfScalar(u8, text[0..cut], '[')) |open| {
+ if (std.mem.indexOfScalarPos(u8, text, open, ']') orelse text.len >= cut) cut = open;
}
- while (cut > 0 and ops[cut - 1] == ' ') cut -= 1;
- u.text(.mono, size, c.operands, base_y, ops[0..cut], theme.color.code.plain);
- u.text(.mono, size, c.operands + @as(f32, @floatFromInt(cut)) * adv, base_y, "\u{2026}", t.faint);
+ while (cut > 0 and text[cut - 1] == ' ') cut -= 1;
+ const shown_cells = ops.bytes > 0 and cut >= ops.after;
+ u.text(.mono, size, c.operands, base_y, text[0..if (shown_cells) ops.after else cut], ink);
+ var end = c.operands + @as(f32, @floatFromInt(cut)) * adv;
+ if (shown_cells) {
+ cells(u, at_after, base_y, ops.bytes);
+ u.text(.mono, size, at_after + extra, base_y, text[ops.after..cut], ink);
+ end += extra;
+ }
+ u.text(.mono, size, end, base_y, "\u{2026}", t.faint);
}
/// The register an instruction leaves a value in, if that is all it does
@@ -526,8 +1009,12 @@ fn full(name: []const u8) ?[]const u8 {
/// instructions over the pc (fewer near its start), the pc's, and as many
/// after it as fill `room`; past the function's end, `outside`.
fn listing(u: ui.Ui, rec: *const Recording, i: u64, room: usize, above: usize) Listing {
+ return listingAt(u, rec, i, rec.register(i, "rip"), room, above);
+}
+
+/// The same round the instruction at `pc` (in the window, `Listing.pc`).
+pub fn listingAt(u: ui.Ui, rec: *const Recording, i: u64, pc: u64, room: usize, above: usize) Listing {
const out = u.f.scratch.alloc(Insn, room) catch return .{ .rows = &.{}, .pc = 0 };
- const pc = rec.register(i, "rip");
var buf: [256]u8 = undefined;
var up: [16]Insn = undefined;
var n_up: usize = 0;
@@ -570,6 +1057,18 @@ fn merge(u: ui.Ui, a: []const Insn, b: []const Insn) ?struct { rows: []const Ins
return .{ .rows = out, .from = if (lo.ptr == a.ptr) 0 else at, .to = if (lo.ptr == b.ptr) 0 else at };
}
+test "a register's size, by its name" {
+ try std.testing.expectEqual(@as(?u8, 8), registerSize("rcx"));
+ try std.testing.expectEqual(@as(?u8, 4), registerSize("eax"));
+ try std.testing.expectEqual(@as(?u8, 4), registerSize("r10d"));
+ try std.testing.expectEqual(@as(?u8, 2), registerSize("ax"));
+ try std.testing.expectEqual(@as(?u8, 1), registerSize("dil"));
+ try std.testing.expectEqual(@as(?u8, 1), registerSize("al"));
+ try std.testing.expectEqual(@as(?u8, 16), registerSize("xmm0"));
+ try std.testing.expectEqual(@as(?u8, null), registerSize("0x10"));
+ try std.testing.expectEqual(@as(?u8, null), registerSize("fs:[0x28]"));
+}
+
test "a register is known by any of its widths" {
try std.testing.expectEqualStrings("rax", full("eax").?);
try std.testing.expectEqualStrings("rdi", full("rdi").?);