diff options
Diffstat (limited to 'anim/build.zig')
| -rw-r--r-- | anim/build.zig | 41 |
1 files changed, 29 insertions, 12 deletions
diff --git a/anim/build.zig b/anim/build.zig index 2f50e4a..5646f1a 100644 --- a/anim/build.zig +++ b/anim/build.zig @@ -25,7 +25,11 @@ pub fn build(b: *std.Build) void { const sb = sketchbook.init(b, .{ .target = target, .optimize = optimize }); const zt = b.dependency("ztrace", .{ .target = target, .optimize = optimize }); const pardes = b.dependency("pardes", .{ .target = target, .optimize = optimize, .@"tree-sitter" = .minimal }); - const ztrace = zt.artifact("ztrace"); + // The tools a recording is made with, always optimized: a step through + // the agent's or the runtime's code is a moment of the recording, and + // a slow tracer stretches the clock's retry loops it steps through. + const tools = b.dependency("ztrace", .{ .target = target, .optimize = .ReleaseFast }); + const ztrace = tools.artifact("ztrace"); const imports: []const std.Build.Module.Import = &.{ .{ .name = "anim", .module = sb.modules.anim }, @@ -44,8 +48,8 @@ pub fn build(b: *std.Build) void { var table: std.ArrayList(u8) = .empty; // The pass and the agent to preload, as ztrace's own build makes and names them. - const plugin = zt.namedLazyPath("ztrace-pass"); - const agent = zt.namedLazyPath("ztrace-agent"); + const plugin = tools.namedLazyPath("ztrace-pass"); + const agent = tools.namedLazyPath("ztrace-agent"); const musl = b.resolveTargetQuery(.{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .musl }); const Recording = struct { @@ -56,10 +60,15 @@ pub fn build(b: *std.Build) void { /// they point at, and the instructions at the pc. by: []const u8, /// Compiled by `ztrace cc` to tell these of itself as well (its - /// calls, its variables with their types, every store and load); - /// null for the program as the compiler alone makes it (static, - /// unoptimised), whose instructions are then all its own. + /// variables with their types), for the functions and globals + /// `only` names: everything else is the compiler's alone. Null for + /// the program as the compiler alone makes it (static, unoptimised), + /// whose instructions are then all its own. instr: ?[]const u8 = null, + only: []const u8 = "*", + /// Run through to here before the first stop: the loader, the C + /// library's start, and what the scene does not show. + from: ?[]const u8 = null, /// With the agent preloaded: `malloc` and `free` too. alloc: bool = false, /// A file of tools/ it reads, by its bare name. @@ -68,20 +77,27 @@ pub fn build(b: *std.Build) void { for ([_]Recording{ .{ .name = "steps", .source = "fib.c", .by = "insn" }, .{ .name = "hello", .source = "hello.c", .by = "line", .reads = "note" }, - .{ .name = "sort", .source = "sort.c", .by = "line", .instr = "calls,vars,stores,loads" }, - .{ .name = "list", .source = "list.c", .by = "line", .instr = "calls,vars,stores,loads", .alloc = true }, + // By instruction, as `steps` is: the registers are the program's + // own, so they strike and link. Only the variables the scenes name + // are told by the instrumentation (each a call into its runtime, + // stepped like any other); `list` starts at `reverse`, its pushes + // (the agent's and the runtime's first calls) run through. + .{ .name = "sort", .source = "sort.c", .by = "insn", .instr = "vars", .only = "sort,a", .from = "main" }, + .{ .name = "list", .source = "list.c", .by = "insn", .instr = "vars", .only = "push,reverse,head", .from = "reverse", .alloc = true }, }) |r| { const source = b.path(b.fmt("tools/{s}", .{r.source})); var program: std.Build.LazyPath = undefined; if (r.instr) |instr| { const cc = b.addRunArtifact(ztrace); - cc.addArgs(&.{ "cc", "--instr", instr, "--plugin" }); + cc.addArgs(&.{ "cc", "--instr", instr, "--only", r.only, "--plugin" }); cc.addFileArg(plugin); cc.addArg("--rt"); - cc.addArtifactArg(zt.artifact("ztrace-rt")); + cc.addArtifactArg(tools.artifact("ztrace-rt")); // Not position-independent: code and heap at short addresses, as // the design's columns are drawn for (seven digits, not twelve). - cc.addArgs(&.{ "--", "clang", "-O0", "-g", "-no-pie" }); + // Bound at load and with no canary: no resolver and no check is + // stepped through that the source does not say. + cc.addArgs(&.{ "--", "clang", "-O0", "-g", "-no-pie", "-fno-stack-protector", "-Wl,-z,now" }); cc.addFileArg(source); cc.addArg("-o"); program = cc.addOutputFileArg(r.name); @@ -99,6 +115,7 @@ pub fn build(b: *std.Build) void { const run = b.addSystemCommand(&.{ "env", "-i", "setarch", "-R" }); run.addArtifactArg(ztrace); run.addArgs(&.{ "record", "--by", r.by, "--stack", "256", "-s", "64" }); + if (r.from) |place| run.addArgs(&.{ "--from", place }); // What an instrumented program tells of itself comes through a ring. if (r.instr != null) run.addArg("--ring"); if (r.alloc) { @@ -205,7 +222,7 @@ pub fn build(b: *std.Build) void { \\mkdir -p out \\"$0" --state "$1" --export - --size "$2" --fps 60 | \\ ffmpeg -loglevel error -y -f rawvideo -pix_fmt rgba -s "$2" -r 60 -i - \ - \\ -c:v libx264 -crf 14 -preset slow -pix_fmt yuv420p \ + \\ -c:v libx264 -crf 14 -preset slow -g 600 -pix_fmt yuv420p \ \\ -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv "$3" }); video.addArtifactArg(exe); |
