@zigc/lib 0.17.0-dev.44 → 0.17.0-dev.607

package/c/strings.zig

@@ -81,41 +81,3 @@ fn __strncasecmp_l(a: [*:0]const c_char, b: [*:0]const c_char, n: usize, locale:
     _ = locale;
     return strncasecmp(a, b, n);
 }
-
-test bzero {
-    var array: [10]u8 = [_]u8{ '1', '2', '3', '4', '5', '6', '7', '8', '9', '0' };
-    var a = std.mem.zeroes([array.len]u8);
-    a[9] = '0';
-    bzero(&array[0], 9);
-    try std.testing.expect(std.mem.eql(u8, &array, &a));
-}
-
-test firstBitSet {
-    try std.testing.expectEqual(0, firstBitSet(usize, 0));
-
-    for (0..@bitSizeOf(usize)) |i| {
-        const bit = @as(usize, 1) << @intCast(i);
-
-        try std.testing.expectEqual(i + 1, firstBitSet(usize, bit));
-    }
-}
-
-test strcasecmp {
-    try std.testing.expect(strcasecmp(@ptrCast("a"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("a")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("b")) < 0);
-    try std.testing.expect(strcasecmp(@ptrCast("b"), @ptrCast("A")) > 0);
-    try std.testing.expect(strcasecmp(@ptrCast("A"), @ptrCast("A")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("B"), @ptrCast("b")) == 0);
-    try std.testing.expect(strcasecmp(@ptrCast("bb"), @ptrCast("AA")) > 0);
-}
-
-test strncasecmp {
-    try std.testing.expect(strncasecmp(@ptrCast("a"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("a"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("b"), 1) < 0);
-    try std.testing.expect(strncasecmp(@ptrCast("b"), @ptrCast("A"), 1) > 0);
-    try std.testing.expect(strncasecmp(@ptrCast("A"), @ptrCast("A"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("B"), @ptrCast("b"), 1) == 0);
-    try std.testing.expect(strncasecmp(@ptrCast("bb"), @ptrCast("AA"), 2) > 0);
-}

package/c/unistd.zig

@@ -21,6 +21,9 @@ comptime {
         symbol(&chrootLinux, "chroot");
         symbol(&ctermidLinux, "ctermid");
         symbol(&dupLinux, "dup");
+        symbol(&dup2Linux, "dup2");
+        symbol(&dup3Linux, "dup3");
+        symbol(&dup3Linux, "__dup3");
 
         symbol(&getegidLinux, "getegid");
         symbol(&geteuidLinux, "geteuid");
@@ -101,6 +104,31 @@ fn dupLinux(fd: c_int) callconv(.c) c_int {
     return errno(linux.dup(fd));
 }
 
+fn dup2Linux(old: c_int, new: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+    while (res == busy) res = linux.dup2(old, new);
+    return errno(res);
+}
+
+fn dup3Linux(old: c_int, new: c_int, flags: c_int) callconv(.c) c_int {
+    const busy: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.BUSY)));
+    var res = busy;
+
+    if (@hasField(linux.SYS, "dup3")) {
+        while (res == busy) res = linux.dup3(old, new, @intCast(flags));
+    } else if (@hasField(linux.SYS, "dup2")) {
+        const cloexec: c_int = @bitCast(linux.O{ .CLOEXEC = true });
+        const inval: usize = @bitCast(-@as(isize, @intFromEnum(linux.E.INVAL)));
+        if (old == new or (flags & ~cloexec != 0)) return errno(inval);
+        while (res == busy) res = linux.dup2(old, new);
+        _ = if (res >= 0 and (flags & cloexec == cloexec)) linux.fcntl(new, linux.F.SETFD, linux.FD_CLOEXEC);
+    } else {
+        return errno(@bitCast(-@as(isize, @intFromEnum(linux.E.NOSYS))));
+    }
+    return errno(res);
+}
+
 fn getegidLinux() callconv(.c) linux.gid_t {
     return linux.getegid();
 }
@@ -206,32 +234,6 @@ fn swab(noalias src_ptr: *const anyopaque, noalias dest_ptr: *anyopaque, n: isiz
     }
 }
 
-test swab {
-    var a: [4]u8 = undefined;
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 4);
-    try std.testing.expectEqualSlices(u8, "badc", &a);
-
-    // Partial copy
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 2);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-
-    // n < 1
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 0);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, -1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-
-    // Odd n
-    @memset(a[0..], '\x00');
-    swab("abcd", &a, 1);
-    try std.testing.expectEqualSlices(u8, "\x00" ** 4, &a);
-    swab("abcd", &a, 3);
-    try std.testing.expectEqualSlices(u8, "ba\x00\x00", &a);
-}
-
 fn close(fd: std.c.fd_t) callconv(.c) c_int {
     const signed: isize = @bitCast(linux.close(fd));
     if (signed < 0) {

package/c/wchar.zig

@@ -5,6 +5,7 @@ const wint_t = std.c.wint_t;
 const wchar_t = std.c.wchar_t;
 
 const symbol = @import("../c.zig").symbol;
+const c = std.c;
 
 comptime {
     if (builtin.target.isMuslLibC() or builtin.target.isWasiLibC()) {
@@ -30,6 +31,7 @@ comptime {
         symbol(&wcspbrk, "wcspbrk");
         symbol(&wcstok, "wcstok");
         symbol(&wcsstr, "wcsstr");
+        symbol(&wcsdup, "wcsdup");
         symbol(&wcswcs, "wcswcs");
     }
 
@@ -189,3 +191,11 @@ fn wcsstr(noalias haystack: [*:0]const wchar_t, noalias needle: [*:0]const wchar
 fn wcswcs(noalias haystack: [*:0]const wchar_t, noalias needle: [*:0]const wchar_t) callconv(.c) ?[*:0]wchar_t {
     return wcsstr(haystack, needle);
 }
+
+fn wcsdup(str: [*:0]const wchar_t) callconv(.c) ?[*:0]wchar_t {
+    const len = wcslen(str);
+    const size = (len + 1) * @sizeOf(wchar_t);
+    const d_opaque = c.malloc(size) orelse return null;
+    const d: [*]wchar_t = @ptrCast(@alignCast(d_opaque));
+    return @ptrCast(wmemcpy(d, str, len + 1));
+}

package/c.zig

@@ -2,8 +2,7 @@
 //! bundled libcs.
 //!
 //! mingw-w64 libc is not fully statically linked, so some symbols don't need
-//! to be exported. However, a future enhancement could be eliminating Zig's
-//! dependency on msvcrt dll even when linking libc and targeting Windows.
+//! to be exported.
 
 const builtin = @import("builtin");
 const std = @import("std");
@@ -69,6 +68,7 @@ comptime {
         _ = @import("c/malloc.zig");
     }
     _ = @import("c/math.zig");
+    _ = @import("c/pthread.zig");
     _ = @import("c/search.zig");
     _ = @import("c/stdlib.zig");
     _ = @import("c/string.zig");

package/{std/Build → compiler/Maker}/Fuzz.zig

@@ -1,24 +1,25 @@
-const std = @import("../std.zig");
-const Io = std.Io;
+const Fuzz = @This();
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
 const Build = std.Build;
-const Cache = Build.Cache;
-const Step = std.Build.Step;
+const Cache = std.Build.Cache;
+const Coverage = std.debug.Coverage;
+const Configuration = std.Build.Configuration;
+const Io = std.Io;
+const abi = std.Build.abi.fuzz;
 const assert = std.debug.assert;
 const fatal = std.process.fatal;
-const Allocator = std.mem.Allocator;
 const log = std.log;
-const Coverage = std.debug.Coverage;
-const abi = Build.abi.fuzz;
 
-const Fuzz = @This();
-const build_runner = @import("root");
+const Maker = @import("../Maker.zig");
+const WebServer = @import("WebServer.zig");
 
-gpa: Allocator,
-io: Io,
+maker: *Maker,
 mode: Mode,
 
 /// Allocated into `gpa`.
-run_steps: []const *Step.Run,
+run_steps: []const Configuration.Step.Index,
 
 group: Io.Group,
 root_prog_node: std.Progress.Node,
@@ -33,7 +34,7 @@ queue_cond: Io.Condition,
 msg_queue: std.ArrayList(Msg),
 
 pub const Mode = union(enum) {
-    forever: struct { ws: *Build.WebServer },
+    forever: struct { ws: *WebServer },
     limit: Limited,
 
     pub const Limited = struct {
@@ -49,7 +50,7 @@ const Msg = union(enum) {
             unique: u64,
             coverage: u64,
         },
-        run: *Step.Run,
+        run: Configuration.Step.Index,
     },
     entry_point: struct {
         coverage_id: u64,
@@ -74,45 +75,50 @@ const CoverageMap = struct {
 };
 
 pub fn init(
-    gpa: Allocator,
-    io: Io,
-    all_steps: []const *Build.Step,
+    maker: *Maker,
+    all_steps: []const Configuration.Step.Index,
     root_prog_node: std.Progress.Node,
     mode: Mode,
 ) error{ OutOfMemory, Canceled }!Fuzz {
-    const run_steps: []const *Step.Run = steps: {
-        var steps: std.ArrayList(*Step.Run) = .empty;
+    const graph = maker.graph;
+    const gpa = graph.cache.gpa;
+    const io = graph.io;
+    const conf = &maker.scanned_config.configuration;
+
+    const run_steps: []const Configuration.Step.Index = steps: {
+        var steps: std.ArrayList(Configuration.Step.Index) = .empty;
         defer steps.deinit(gpa);
         const rebuild_node = root_prog_node.start("Rebuilding Unit Tests", 0);
         defer rebuild_node.end();
         var rebuild_group: Io.Group = .init;
         defer rebuild_group.cancel(io);
 
-        for (all_steps) |step| {
-            const run = step.cast(Step.Run) orelse continue;
-            if (run.producer == null) continue;
+        for (all_steps) |step_index| {
+            const conf_run = step_index.ptr(conf).extended.cast(conf, Configuration.Step.Run) orelse continue;
+            if (conf_run.producer.value == null) continue;
+            const run = &maker.stepByIndex(step_index).extended.run;
             if (run.fuzz_tests.items.len == 0) continue;
-            try steps.append(gpa, run);
-            rebuild_group.async(io, rebuildTestsWorkerRun, .{ run, gpa, rebuild_node });
+            try steps.append(gpa, step_index);
+            rebuild_group.async(io, rebuildTestsWorkerRun, .{ maker, step_index, rebuild_node });
         }
 
         if (steps.items.len == 0) fatal("no fuzz tests found", .{});
         rebuild_node.setEstimatedTotalItems(steps.items.len);
-        const run_steps = try gpa.dupe(*Step.Run, steps.items);
+        const run_steps = try gpa.dupe(Configuration.Step.Index, steps.items);
         try rebuild_group.await(io);
         break :steps run_steps;
     };
     errdefer gpa.free(run_steps);
 
-    for (run_steps) |run| {
+    for (run_steps) |run_index| {
+        const run = &maker.stepByIndex(run_index).extended.run;
         assert(run.fuzz_tests.items.len > 0);
         if (run.rebuilt_executable == null)
             fatal("one or more unit tests failed to be rebuilt in fuzz mode", .{});
     }
 
     return .{
-        .gpa = gpa,
-        .io = io,
+        .maker = maker,
         .mode = mode,
         .run_steps = run_steps,
         .group = .init,
@@ -127,7 +133,10 @@ pub fn init(
 }
 
 pub fn start(fuzz: *Fuzz) void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
+
     fuzz.prog_node = fuzz.root_prog_node.start("Fuzzing", 0);
 
     if (fuzz.mode == .forever) {
@@ -136,71 +145,119 @@ pub fn start(fuzz: *Fuzz) void {
             fatal("unable to spawn coverage task: {t}", .{err});
     }
 
-    for (fuzz.run_steps) |run| {
+    for (fuzz.run_steps) |run_index| {
+        const run = &maker.stepByIndex(run_index).extended.run;
         assert(run.rebuilt_executable != null);
-        fuzz.group.async(io, fuzzWorkerRun, .{ fuzz, run });
+        fuzz.group.async(io, fuzzWorkerRun, .{ fuzz, run_index });
     }
 }
 
 pub fn deinit(fuzz: *Fuzz) void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
+    const gpa = maker.gpa;
+
     fuzz.group.cancel(io);
     fuzz.prog_node.end();
-    fuzz.gpa.free(fuzz.run_steps);
+    gpa.free(fuzz.run_steps);
 }
 
-fn rebuildTestsWorkerRun(run: *Step.Run, gpa: Allocator, parent_prog_node: std.Progress.Node) void {
-    rebuildTestsWorkerRunFallible(run, gpa, parent_prog_node) catch |err| {
-        const compile = run.producer.?;
-        log.err("step '{s}': failed to rebuild in fuzz mode: {t}", .{ compile.step.name, err });
+fn rebuildTestsWorkerRun(
+    maker: *Maker,
+    run_index: Configuration.Step.Index,
+    parent_prog_node: std.Progress.Node,
+) void {
+    rebuildTestsWorkerRunFallible(maker, run_index, parent_prog_node) catch |err| {
+        const conf = &maker.scanned_config.configuration;
+        const conf_run = run_index.ptr(conf).extended.cast(conf, Configuration.Step.Run).?;
+        const comp_index = conf_run.producer.value.?;
+        const step_name = comp_index.ptr(conf).name.slice(conf);
+        log.err("step {s}: failed to rebuild in fuzz mode: {t}", .{ step_name, err });
     };
 }
 
-fn rebuildTestsWorkerRunFallible(run: *Step.Run, gpa: Allocator, parent_prog_node: std.Progress.Node) !void {
-    const graph = run.step.owner.graph;
+fn rebuildTestsWorkerRunFallible(
+    maker: *Maker,
+    run_index: Configuration.Step.Index,
+    parent_prog_node: std.Progress.Node,
+) !void {
+    const graph = maker.graph;
     const io = graph.io;
-    const compile = run.producer.?;
-    const prog_node = parent_prog_node.start(compile.step.name, 0);
+    const gpa = maker.gpa;
+    const conf = &maker.scanned_config.configuration;
+    const run = &maker.stepByIndex(run_index).extended.run;
+    const conf_run = run_index.ptr(conf).extended.cast(conf, Configuration.Step.Run).?;
+    const comp_index = conf_run.producer.value.?;
+    const comp_step = maker.stepByIndex(comp_index);
+    const comp = &comp_step.extended.compile;
+    const conf_comp_step = comp_index.ptr(conf);
+    const conf_comp = conf_comp_step.extended.cast(conf, Configuration.Step.Compile).?;
+    const root_module = conf_comp.root_module.get(conf);
+    const target = root_module.resolved_target.get(conf).?.result.get(conf);
+
+    const prog_node = parent_prog_node.start(conf_comp_step.name.slice(conf), 0);
     defer prog_node.end();
 
-    const result = compile.rebuildInFuzzMode(gpa, prog_node);
+    const result = comp.rebuildInFuzzMode(maker, comp_index, prog_node);
 
-    const show_compile_errors = compile.step.result_error_bundle.errorMessageCount() > 0;
-    const show_error_msgs = compile.step.result_error_msgs.items.len > 0;
-    const show_stderr = compile.step.result_stderr.len > 0;
+    const show_compile_errors = comp_step.result_error_bundle.errorMessageCount() > 0;
+    const show_error_msgs = comp_step.result_error_msgs.items.len > 0;
+    const show_stderr = comp_step.result_stderr.len > 0;
 
     if (show_error_msgs or show_compile_errors or show_stderr) {
         var buf: [256]u8 = undefined;
         const stderr = try io.lockStderr(&buf, graph.stderr_mode);
         defer io.unlockStderr();
-        build_runner.printErrorMessages(gpa, &compile.step, .{}, stderr.terminal(), .verbose, .indent) catch {};
+        maker.printErrorMessages(comp_index, .{}, stderr.terminal(), .verbose, .indent) catch {};
     }
 
     const rebuilt_bin_path = result catch |err| switch (err) {
         error.MakeFailed => return,
         else => |other| return other,
     };
-    run.rebuilt_executable = try rebuilt_bin_path.join(gpa, compile.out_filename);
+    const compile_filename = try std.zig.binNameAlloc(gpa, .{
+        .root_name = conf_comp.root_name.slice(conf),
+        .cpu_arch = target.flags.cpu_arch.unwrap().?,
+        .os_tag = target.flags.os_tag.unwrap().?,
+        .ofmt = target.flags.object_format.unwrap().?,
+        .abi = target.flags.abi.unwrap().?,
+        .output_mode = switch (conf_comp.flags3.kind) {
+            .lib => .Lib,
+            .obj, .test_obj => .Obj,
+            .exe, .@"test" => .Exe,
+        },
+        .link_mode = conf_comp.flags2.linkage.unwrap(),
+        .version = if (conf_comp.version.value) |v|
+            std.SemanticVersion.parse(v.slice(conf)) catch unreachable
+        else
+            null,
+    });
+    defer gpa.free(compile_filename);
+
+    run.rebuilt_executable = try rebuilt_bin_path.join(gpa, compile_filename);
 }
 
-fn fuzzWorkerRun(fuzz: *Fuzz, run: *Step.Run) void {
-    const owner = run.step.owner;
-    const gpa = owner.allocator;
-    const graph = owner.graph;
+fn fuzzWorkerRun(fuzz: *Fuzz, run_index: Configuration.Step.Index) void {
+    const maker = fuzz.maker;
+    const graph = maker.graph;
     const io = graph.io;
+    const conf = &maker.scanned_config.configuration;
+    const run = &maker.stepByIndex(run_index).extended.run;
 
-    run.rerunInFuzzMode(fuzz, fuzz.prog_node) catch |err| switch (err) {
+    run.rerunInFuzzMode(run_index, fuzz, fuzz.prog_node) catch |err| switch (err) {
         error.MakeFailed => {
             var buf: [256]u8 = undefined;
             const stderr = io.lockStderr(&buf, graph.stderr_mode) catch |e| switch (e) {
                 error.Canceled => return,
             };
             defer io.unlockStderr();
-            build_runner.printErrorMessages(gpa, &run.step, .{}, stderr.terminal(), .verbose, .indent) catch {};
+            maker.printErrorMessages(run_index, .{}, stderr.terminal(), .verbose, .indent) catch {};
             return;
         },
         else => {
-            log.err("step '{s}': failed to rerun in fuzz mode: {t}", .{ run.step.name, err });
+            const step_name = run_index.ptr(conf).name.slice(conf);
+            log.err("step {s}: failed to rerun in fuzz mode: {t}", .{ step_name, err });
             return;
         },
     };
@@ -208,19 +265,25 @@ fn fuzzWorkerRun(fuzz: *Fuzz, run: *Step.Run) void {
 
 pub fn serveSourcesTar(fuzz: *Fuzz, req: *std.http.Server.Request) !void {
     assert(fuzz.mode == .forever);
+    const maker = fuzz.maker;
+    const gpa = maker.gpa;
+    const conf = &maker.scanned_config.configuration;
 
-    var arena_state: std.heap.ArenaAllocator = .init(fuzz.gpa);
+    var arena_state: std.heap.ArenaAllocator = .init(gpa);
     defer arena_state.deinit();
     const arena = arena_state.allocator();
 
     const DedupTable = std.ArrayHashMapUnmanaged(Build.Cache.Path, void, Build.Cache.Path.TableAdapter, false);
     var dedup_table: DedupTable = .empty;
-    defer dedup_table.deinit(fuzz.gpa);
+    defer dedup_table.deinit(gpa);
 
-    for (fuzz.run_steps) |run_step| {
-        const compile_inputs = run_step.producer.?.step.inputs.table;
+    for (fuzz.run_steps) |run_index| {
+        const conf_run = run_index.ptr(conf).extended.cast(conf, Configuration.Step.Run) orelse continue;
+        const comp_index = conf_run.producer.value.?;
+        const comp_step = maker.stepByIndex(comp_index);
+        const compile_inputs = comp_step.inputs.table;
         for (compile_inputs.keys(), compile_inputs.values()) |dir_path, *file_list| {
-            try dedup_table.ensureUnusedCapacity(fuzz.gpa, file_list.items.len);
+            try dedup_table.ensureUnusedCapacity(gpa, file_list.items.len);
             for (file_list.items) |sub_path| {
                 if (!std.mem.endsWith(u8, sub_path, ".zig")) continue;
                 const joined_path = try dir_path.join(arena, sub_path);
@@ -259,7 +322,9 @@ pub fn sendUpdate(
     socket: *std.http.Server.WebSocket,
     prev: *Previous,
 ) !void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
 
     try fuzz.coverage_mutex.lock(io);
     defer fuzz.coverage_mutex.unlock(io);
@@ -330,7 +395,9 @@ fn coverageRun(fuzz: *Fuzz) void {
 }
 
 fn coverageRunCancelable(fuzz: *Fuzz) Io.Cancelable!void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
 
     try fuzz.queue_mutex.lock(io);
     defer fuzz.queue_mutex.unlock(io);
@@ -352,11 +419,15 @@ fn coverageRunCancelable(fuzz: *Fuzz) Io.Cancelable!void {
         fuzz.msg_queue.clearRetainingCapacity();
     }
 }
-fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutOfMemory, AlreadyReported, Canceled }!void {
+fn prepareTables(fuzz: *Fuzz, run_index: Configuration.Step.Index, coverage_id: u64) error{ OutOfMemory, AlreadyReported, Canceled }!void {
     assert(fuzz.mode == .forever);
     const ws = fuzz.mode.forever.ws;
-    const gpa = fuzz.gpa;
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
+    const gpa = maker.gpa;
+    const conf = &maker.scanned_config.configuration;
+    const cache_root = graph.local_cache_root;
 
     try fuzz.coverage_mutex.lock(io);
     defer fuzz.coverage_mutex.unlock(io);
@@ -382,37 +453,45 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
     };
     errdefer gop.value_ptr.coverage.deinit(gpa);
 
-    const rebuilt_exe_path = run_step.rebuilt_executable.?;
-    const target = run_step.producer.?.rootModuleTarget();
+    const run_step = maker.stepByIndex(run_index);
+    const conf_run_step = run_index.ptr(conf);
+    const conf_run = conf_run_step.extended.cast(conf, Configuration.Step.Run).?;
+    const comp_index = conf_run.producer.value.?;
+    const conf_comp_step = comp_index.ptr(conf);
+    const conf_comp = conf_comp_step.extended.cast(conf, Configuration.Step.Compile).?;
+    const rebuilt_exe_path = run_step.extended.run.rebuilt_executable.?;
+    const root_module = conf_comp.root_module.get(conf);
+    const target = root_module.resolved_target.get(conf).?.result.get(conf);
+
     var debug_info = std.debug.Info.load(
         gpa,
         io,
         rebuilt_exe_path,
         &gop.value_ptr.coverage,
-        target.ofmt,
-        target.cpu.arch,
+        target.flags.object_format.unwrap().?,
+        target.flags.cpu_arch.unwrap().?,
     ) catch |err| {
-        log.err("step '{s}': failed to load debug information for '{f}': {t}", .{
-            run_step.step.name, rebuilt_exe_path, err,
+        log.err("step {s}: failed to load debug information for {f}: {t}", .{
+            conf_run_step.name.slice(conf), rebuilt_exe_path, err,
         });
         return error.AlreadyReported;
     };
     defer debug_info.deinit(gpa);
 
     const coverage_file_path: Build.Cache.Path = .{
-        .root_dir = run_step.step.owner.cache_root,
+        .root_dir = cache_root,
         .sub_path = "v/" ++ std.fmt.hex(coverage_id),
     };
     var coverage_file = coverage_file_path.root_dir.handle.openFile(io, coverage_file_path.sub_path, .{}) catch |err| {
-        log.err("step '{s}': failed to load coverage file '{f}': {t}", .{
-            run_step.step.name, coverage_file_path, err,
+        log.err("step {s}: failed to load coverage file {f}: {t}", .{
+            conf_run_step.name.slice(conf), coverage_file_path, err,
         });
         return error.AlreadyReported;
     };
     defer coverage_file.close(io);
 
     const file_size = coverage_file.length(io) catch |err| {
-        log.err("unable to check len of coverage file '{f}': {t}", .{ coverage_file_path, err });
+        log.err("unable to check len of coverage file {f}: {t}", .{ coverage_file_path, err });
         return error.AlreadyReported;
     };
 
@@ -424,7 +503,7 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
         coverage_file.handle,
         0,
     ) catch |err| {
-        log.err("failed to map coverage file '{f}': {t}", .{ coverage_file_path, err });
+        log.err("failed to map coverage file {f}: {t}", .{ coverage_file_path, err });
         return error.AlreadyReported;
     };
     gop.value_ptr.mapped_memory = mapped_memory;
@@ -462,7 +541,10 @@ fn prepareTables(fuzz: *Fuzz, run_step: *Step.Run, coverage_id: u64) error{ OutO
 }
 
 fn addEntryPoint(fuzz: *Fuzz, coverage_id: u64, addr: u64) error{ AlreadyReported, OutOfMemory, Canceled }!void {
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
+    const gpa = maker.gpa;
 
     try fuzz.coverage_mutex.lock(io);
     defer fuzz.coverage_mutex.unlock(io);
@@ -508,12 +590,16 @@ fn addEntryPoint(fuzz: *Fuzz, coverage_id: u64, addr: u64) error{ AlreadyReporte
             });
         }
     }
-    try coverage_map.entry_points.append(fuzz.gpa, @intCast(index));
+    try coverage_map.entry_points.append(gpa, @intCast(index));
 }
 
 pub fn waitAndPrintReport(fuzz: *Fuzz) Io.Cancelable!void {
     assert(fuzz.mode == .limit);
-    const io = fuzz.io;
+    const maker = fuzz.maker;
+    const graph = maker.graph;
+    const io = graph.io;
+    const cache_root = graph.local_cache_root;
+    const conf = &maker.scanned_config.configuration;
 
     try fuzz.group.await(io);
     fuzz.group = .init;
@@ -523,13 +609,15 @@ pub fn waitAndPrintReport(fuzz: *Fuzz) Io.Cancelable!void {
         if (msg != .coverage) continue;
 
         const cov = msg.coverage;
+        const run_step_name = cov.run.ptr(conf).name.slice(conf);
+        const run = &maker.stepByIndex(cov.run).extended.run;
         const coverage_file_path: std.Build.Cache.Path = .{
-            .root_dir = cov.run.step.owner.cache_root,
+            .root_dir = cache_root,
             .sub_path = "v/" ++ std.fmt.hex(cov.id),
         };
         var coverage_file = coverage_file_path.root_dir.handle.openFile(io, coverage_file_path.sub_path, .{}) catch |err| {
-            fatal("step '{s}': failed to load coverage file '{f}': {t}", .{
-                cov.run.step.name, coverage_file_path, err,
+            fatal("step {s}: failed to load coverage file {f}: {t}", .{
+                run_step_name, coverage_file_path, err,
             });
         };
         defer coverage_file.close(io);
@@ -540,14 +628,14 @@ pub fn waitAndPrintReport(fuzz: *Fuzz) Io.Cancelable!void {
 
         var header: fuzz_abi.SeenPcsHeader = undefined;
         r.interface.readSliceAll(std.mem.asBytes(&header)) catch |err| {
-            fatal("step '{s}': failed to read from coverage file '{f}': {t}", .{
-                cov.run.step.name, coverage_file_path, err,
+            fatal("step {s}: failed to read from coverage file {f}: {t}", .{
+                run_step_name, coverage_file_path, err,
             });
         };
 
         if (header.pcs_len == 0) {
-            fatal("step '{s}': corrupted coverage file '{f}': pcs_len was zero", .{
-                cov.run.step.name, coverage_file_path,
+            fatal("step {s}: corrupted coverage file {f}: pcs_len was zero", .{
+                run_step_name, coverage_file_path,
             });
         }
 
@@ -555,8 +643,8 @@ pub fn waitAndPrintReport(fuzz: *Fuzz) Io.Cancelable!void {
         const chunk_count = fuzz_abi.SeenPcsHeader.seenElemsLen(header.pcs_len);
         for (0..chunk_count) |_| {
             const seen = r.interface.takeInt(usize, .little) catch |err| {
-                fatal("step '{s}': failed to read from coverage file '{f}': {t}", .{
-                    cov.run.step.name, coverage_file_path, err,
+                fatal("step {s}: failed to read from coverage file {f}: {t}", .{
+                    run_step_name, coverage_file_path, err,
                 });
             };
             seen_count += @popCount(seen);
@@ -573,8 +661,8 @@ pub fn waitAndPrintReport(fuzz: *Fuzz) Io.Cancelable!void {
             \\Coverage: {}/{} -> {}/{} ({:.02}%)
             \\
         , .{
-            cov.run.step.name,
-            cov.run.fuzz_tests.items[0],
+            run_step_name,
+            run.fuzz_tests.items[0],
             cov.id,
             cov.cumulative.runs,
             header.n_runs,