summaryrefslogtreecommitdiff
path: root/src/cli/cc.zig
blob: 1d08b516be1bfcdbe94a2c4fac0b4449268060a0 (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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
//! ztrace cc: a compiler command with the instrumentation added, so a
//! program compiled from source records itself under `ztrace run`.
const std = @import("std");
const util = @import("util.zig");
const fail = util.fail;

pub const usage =
    \\usage: ztrace cc [--instr LIST] [--only GLOBS] [--mem GLOBS] [--late] [--plugin SO] [--rt A] -- CLANG ARGS
    \\
    \\Runs CLANG (clang, clang++) with ARGS and -g, the pass plugin and its
    \\options, and when the command links, the runtime:
    \\
    \\  ztrace cc -- clang sort.c -o sort && ztrace run -- ./sort
    \\
    \\  --instr LIST  comma separated, default lines,calls,vars,stores
    \\                  lines   `line` at each source line reached
    \\                  stores  `mem_write`, with the bytes, after each store to a
    \\                          variable or through a pointer; a memset or
    \\                          memcpy is one, of its first 64 KiB at most
    \\                  loads   `mem_read` after each load
    \\                  calls   `call` at function entry, `ret` with the value at exit
    \\                  vars    `variable` for each named local and global:
    \\                          address, size, name, type description
    \\                from stock clang, no plugin and no names:
    \\                  edges   `edge`  (-fsanitize-coverage=trace-pc-guard)
    \\                  cmps    `cmp`, and `edge`: clang compares only along with edges
    \\                          (-fsanitize-coverage=trace-pc-guard,trace-cmp)
    \\                  cyg     `call`, `ret`  (-finstrument-functions)
    \\  --only GLOBS  comma separated; the plugin instruments only the functions
    \\                and globals whose name, source path or source file name
    \\                matches one: 'sort*,*/vdbe.c'
    \\  --mem GLOBS   of those, the functions whose stores and loads are recorded
    \\                (default: all of them). Stores are most of a recording:
    \\                in a large program, name where memory matters.
    \\  --late        instrument after optimization: the stores and lines of the
    \\                code that runs, not of the source
    \\  --plugin SO   the pass (default: ../lib/ztrace-pass.so from this program)
    \\  --rt A        the runtime (default: ../lib/libztrace-rt.a)
    \\
;

pub fn run(init: std.process.Init, args: []const [:0]const u8) !void {
    const arena = init.arena.allocator();
    var instr: []const u8 = "lines,calls,vars,stores";
    var only: ?[]const u8 = null;
    var mem: ?[]const u8 = null;
    var late = false;
    var plugin: ?[]const u8 = null;
    var rt: ?[]const u8 = null;
    var i: usize = 0;
    while (i < args.len) : (i += 1) {
        const arg = args[i];
        if (std.mem.eql(u8, arg, "--")) {
            i += 1;
            break;
        } else if (std.mem.eql(u8, arg, "--late")) {
            late = true;
        } else if (i + 1 < args.len and std.mem.eql(u8, arg, "--instr")) {
            i += 1;
            instr = args[i];
        } else if (i + 1 < args.len and std.mem.eql(u8, arg, "--only")) {
            i += 1;
            only = args[i];
        } else if (i + 1 < args.len and std.mem.eql(u8, arg, "--mem")) {
            i += 1;
            mem = args[i];
        } else if (i + 1 < args.len and std.mem.eql(u8, arg, "--plugin")) {
            i += 1;
            plugin = args[i];
        } else if (i + 1 < args.len and std.mem.eql(u8, arg, "--rt")) {
            i += 1;
            rt = args[i];
        } else fail(usage, .{});
    }
    if (i >= args.len) fail(usage, .{});
    const lib = try std.fs.path.join(arena, &.{ try std.process.executableDirPathAlloc(init.io, arena), "..", "lib" });

    var argv: std.ArrayList([]const u8) = .empty;
    for (args[i..]) |arg| try argv.append(arena, arg);
    // What a command that only links does not use is no warning.
    try argv.appendSlice(arena, &.{ "--start-no-unused-arguments", "-g" });
    // The plugin's own words, which it checks; the rest are clang's flags.
    var pass: std.ArrayList(u8) = .empty;
    var words = std.mem.tokenizeScalar(u8, instr, ',');
    while (words.next()) |word| {
        if (std.mem.eql(u8, word, "edges")) {
            try argv.append(arena, "-fsanitize-coverage=trace-pc-guard");
        } else if (std.mem.eql(u8, word, "cmps")) {
            try argv.append(arena, "-fsanitize-coverage=trace-pc-guard,trace-cmp");
        } else if (std.mem.eql(u8, word, "cyg")) {
            try argv.append(arena, "-finstrument-functions");
        } else try pass.print(arena, "{s}{s}", .{ if (pass.items.len > 0) "," else "", word });
    }
    if (pass.items.len > 0) {
        const so = plugin orelse try std.fs.path.join(arena, &.{ lib, "ztrace-pass.so" });
        // -load as well: the plugin's options must exist when -mllvm is read,
        // which is before -fpass-plugin loads it.
        try argv.appendSlice(arena, &.{ try std.fmt.allocPrint(arena, "-fpass-plugin={s}", .{so}), "-Xclang", "-load", "-Xclang", so });
        try argv.appendSlice(arena, &.{ "-mllvm", try std.fmt.allocPrint(arena, "-ztrace-instr={s}", .{pass.items}) });
        if (only) |globs| try argv.appendSlice(arena, &.{ "-mllvm", try std.fmt.allocPrint(arena, "-ztrace-only={s}", .{globs}) });
        if (mem) |globs| try argv.appendSlice(arena, &.{ "-mllvm", try std.fmt.allocPrint(arena, "-ztrace-mem={s}", .{globs}) });
        if (late) try argv.appendSlice(arena, &.{ "-mllvm", "-ztrace-late" });
    }
    try argv.append(arena, "--end-no-unused-arguments");
    // The command links unless it says where to stop. The whole archive: with
    // -fsanitize-coverage clang links weak callbacks of its own first, and
    // only a runtime already in the link replaces them. -x none: after an
    // -x c the archive would be read as source.
    const links = for (args[i..]) |arg| {
        if (std.mem.eql(u8, arg, "-c") or std.mem.eql(u8, arg, "-S") or std.mem.eql(u8, arg, "-E") or std.mem.eql(u8, arg, "-fsyntax-only")) break false;
    } else true;
    if (links) try argv.appendSlice(arena, &.{ "-x", "none", "-Wl,--whole-archive", rt orelse try std.fs.path.join(arena, &.{ lib, "libztrace-rt.a" }), "-Wl,--no-whole-archive" });

    const err = std.process.replace(init.io, .{ .argv = argv.items });
    fail("{s}: {t}\n", .{ argv.items[0], err });
}