summaryrefslogtreecommitdiff
path: root/src/cli/show.zig
blob: ce8dec495faa7bb9ab43f204dc417b021d0656f8 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
//! ztrace show: what a recording holds, and the program's state at a moment.
const std = @import("std");
const zt = @import("ztrace");
const util = @import("util.zig");

pub const usage =
    \\usage: ztrace show FILE [MOMENT]
    \\
    \\Without MOMENT: how many moments and events, and events by kind.
    \\With one (negative counts from the end): each thread's registers, source
    \\line and open calls, the live heap, the named variables with their
    \\bytes, and the mapped regions, as of that moment.
    \\
;

pub fn run(init: std.process.Init, args: []const [:0]const u8) !void {
    if (args.len < 1 or args.len > 2) util.fail(usage, .{});
    var trace = try zt.Trace.open(init.gpa, init.io, args[0]);
    defer trace.close();
    var buf: [4096]u8 = undefined;
    var file_writer = std.Io.File.stdout().writer(init.io, &buf);
    const w = &file_writer.interface;
    const result = if (args.len == 1) summary(init.gpa, &trace, w) else blk: {
        const n = std.fmt.parseInt(i64, args[1], 10) catch util.fail(usage, .{});
        const index = if (n < 0) @as(i64, @intCast(trace.len)) + n else n;
        if (index < 0 or index >= trace.len) util.fail("{s}: {d} moments, no moment {d}\n", .{ args[0], trace.len, n });
        break :blk state(init.arena.allocator(), &trace, @intCast(index), w);
    };
    result catch |err| switch (err) {
        // The reader went away (`| head`): not an error.
        error.WriteFailed => return,
        else => |e| return e,
    };
    w.flush() catch {};
}

fn summary(gpa: std.mem.Allocator, trace: *zt.Trace, w: *std.Io.Writer) !void {
    var by_kind: [64]u64 = @splat(0);
    var total: u64 = 0;
    for (0..trace.len) |index| {
        var events = try (try trace.moment(index)).events(gpa);
        defer events.deinit(gpa);
        while (events.next()) |item| : (total += 1) by_kind[@intFromEnum(item.ev.kind) & 63] += 1;
    }
    try w.print("{d} moments, {d} events\n", .{ trace.len, total });
    for (by_kind, 0..) |n, kind| {
        if (n != 0) try w.print("{d:>10} {t}\n", .{ n, @as(zt.Kind, @enumFromInt(kind)) });
    }
}

/// A string id as text, or the id itself when the recording never defined it.
fn name(m: zt.store.Moment, arena: std.mem.Allocator, id: u64) ![]const u8 {
    const buf = try arena.alloc(u8, 4096);
    return (try m.string(id, buf)) orelse std.fmt.allocPrint(arena, "#{x}", .{id});
}

fn state(arena: std.mem.Allocator, trace: *zt.Trace, index: u64, w: *std.Io.Writer) !void {
    const m = try trace.moment(index);
    try w.print("moment {d} of {d}, {d} events so far\n", .{ index, trace.len, try m.count() });

    for (try m.threads(arena)) |tid| {
        try w.print("\nthread {d}", .{tid});
        if (try m.line(tid)) |line| try w.print("  {s}:{d}:{d}", .{ try name(m, arena, line.file), line.line, line.column });
        try w.writeAll("\n");
        if (try m.regs(tid)) |regs| {
            inline for (zt.Regs.names, 0..) |reg, i| {
                try w.print("  {s:<6} {x:0>16}{s}", .{ reg, @field(regs, reg), if (i % 3 == 2) "\n" else "" });
            }
            if (zt.Regs.names.len % 3 != 0) try w.writeAll("\n");
        }
        for (try m.stack(arena, tid), 0..) |frame, depth| {
            try w.print("  #{d} {s} from {x} sp {x}\n", .{ depth, try name(m, arena, frame.function), frame.site, frame.sp });
        }
    }

    const heap = try m.heap(arena);
    if (heap.len > 0) try w.print("\nheap: {d} live\n", .{heap.len});
    for (heap) |a| try w.print("  {x:0>12} {d:>8} bytes, by {x}, event {d}\n", .{ a.ptr, a.size, a.pc, a.born });

    const variables = try m.variables(arena);
    if (variables.len > 0) try w.writeAll("\nvariables\n");
    for (variables) |v| {
        var bytes: [16]u8 = undefined;
        var known: [16]bool = undefined;
        const n: usize = @intCast(@min(v.size, bytes.len));
        try m.read(v.addr, bytes[0..n], known[0..n]);
        try w.print("  {x:0>12} {s}: {s} =", .{ v.addr, try name(m, arena, v.name), try name(m, arena, v.type) });
        for (bytes[0..n], known[0..n]) |byte, k| {
            if (k) try w.print(" {x:0>2}", .{byte}) else try w.writeAll(" ??");
        }
        try w.print("{s}\n", .{if (v.size > n) " ..." else ""});
    }

    const mappings = try m.mappings(arena);
    if (mappings.len > 0) try w.writeAll("\nmappings\n");
    for (mappings) |region| {
        var path: []const u8 = "";
        var path_buf: [std.Io.Dir.max_path_bytes]u8 = undefined;
        _ = try m.mapping(region.addr, &path, &path_buf);
        try w.print("  {x:0>12}-{x:0>12} {s}\n", .{ region.addr, region.addr + region.len, path });
    }
}