authorgravatar for kappaloris@gmail.comLoris Cro <kappaloris@gmail.com> 2025-09-25 17:02:43+02:00
committergravatar for kappaloris@gmail.comLoris Cro <kappaloris@gmail.com> 2025-09-25 18:20:19+02:00
log9bb0b43ea3ababb715a15bba8c09ba71e9c3ccc2
treed2f43d4ac88949889e5971327426fb099e576941
parent0feacc2b81679514c0168a6ba4c0decafeb2e43e

implement review suggestions

5 files changed, 56 insertions(+), 78 deletions(-)

lib/compiler/build_runner.zig+10-6
......@@ -280,21 +280,21 @@ pub fn main() !void {
280280 }
281281 } else if (mem.startsWith(u8, arg, "--fuzz=")) {
282282 const value = arg["--fuzz=".len..];
283 if (value.len == 0) fatal("missing argument to --fuzz\n", .{});
283 if (value.len == 0) fatal("missing argument to --fuzz", .{});
284284
285285 const unit: u8 = value[value.len - 1];
286 const digits = switch (value[value.len - 1]) {
286 const digits = switch (unit) {
287287 '0'...'9' => value,
288288 'K', 'M', 'G' => value[0 .. value.len - 1],
289289 else => fatal(
290 "invalid argument to --fuzz, expected a positive number optionally suffixed by one of: [KMG]\n",
290 "invalid argument to --fuzz, expected a positive number optionally suffixed by one of: [KMG]",
291291 .{},
292292 ),
293293 };
294294
295295 const amount = std.fmt.parseInt(u64, digits, 10) catch {
296296 fatal(
297 "invalid argument to --fuzz, expected a positive number optionally suffixed by one of: [KMG]\n",
297 "invalid argument to --fuzz, expected a positive number optionally suffixed by one of: [KMG]",
298298 .{},
299299 );
300300 };
......@@ -305,7 +305,7 @@ pub fn main() !void {
305305 'K' => 1000,
306306 'M' => 1_000_000,
307307 'G' => 1_000_000_000,
308 }) catch fatal("fuzzing limit amount overflows u64\n", .{});
308 }) catch fatal("fuzzing limit amount overflows u64", .{});
309309
310310 fuzz = .{
311311 .limit = .{
......@@ -520,7 +520,11 @@ pub fn main() !void {
520520 };
521521
522522 if (run.web_server) |*web_server| {
523 if (fuzz) |mode| assert(mode == .forever);
523 if (fuzz) |mode| if (mode != .forever) fatal(
524 "error: limited fuzzing is not implemented yet for --webui",
525 .{},
526 );
527
524528 web_server.finishBuild(.{ .fuzz = fuzz != null });
525529 }
526530
lib/compiler/test_runner.zig+17-68
......@@ -56,20 +56,21 @@ pub fn main() void {
5656 }
5757 }
5858
59 fba.reset();
6059 if (builtin.fuzz) {
6160 const cache_dir = opt_cache_dir orelse @panic("missing --cache-dir=[path] argument");
6261 fuzz_abi.fuzzer_init(.fromSlice(cache_dir));
6362 }
6463
64 fba.reset();
65
6566 if (listen) {
66 return mainServer(opt_cache_dir) catch @panic("internal test runner failure");
67 return mainServer() catch @panic("internal test runner failure");
6768 } else {
6869 return mainTerminal();
6970 }
7071}
7172
72fn mainServer(opt_cache_dir: ?[]const u8) !void {
73fn mainServer() !void {
7374 @disableInstrumentation();
7475 var stdin_reader = std.fs.File.stdin().readerStreaming(&stdin_buffer);
7576 var stdout_writer = std.fs.File.stdout().writerStreaming(&stdout_buffer);
......@@ -79,66 +80,14 @@ fn mainServer(opt_cache_dir: ?[]const u8) !void {
7980 .zig_version = builtin.zig_version_string,
8081 });
8182
82 if (builtin.fuzz) blk: {
83 const cache_dir = opt_cache_dir.?;
84 const coverage_id = fuzz_abi.fuzzer_coverage_id();
85 const coverage_file_path: std.Build.Cache.Path = .{
86 .root_dir = .{
87 .path = cache_dir,
88 .handle = std.fs.cwd().openDir(cache_dir, .{}) catch |err| {
89 if (err == error.FileNotFound) {
90 try server.serveCoverageIdMessage(coverage_id, 0, 0, 0);
91 break :blk;
92 }
93
94 fatal("failed to access cache dir '{s}': {s}", .{
95 cache_dir, @errorName(err),
96 });
97 },
98 },
99 .sub_path = "v/" ++ std.fmt.hex(coverage_id),
100 };
101
102 var coverage_file = coverage_file_path.root_dir.handle.openFile(coverage_file_path.sub_path, .{}) catch |err| {
103 if (err == error.FileNotFound) {
104 try server.serveCoverageIdMessage(coverage_id, 0, 0, 0);
105 break :blk;
106 }
107
108 fatal("failed to load coverage file '{f}': {s}", .{
109 coverage_file_path, @errorName(err),
110 });
111 };
112 defer coverage_file.close();
113
114 var rbuf: [0x1000]u8 = undefined;
115 var r = coverage_file.reader(&rbuf);
116
117 var header: fuzz_abi.SeenPcsHeader = undefined;
118 r.interface.readSliceAll(std.mem.asBytes(&header)) catch |err| {
119 fatal("failed to read from coverage file '{f}': {s}", .{
120 coverage_file_path, @errorName(err),
121 });
122 };
123
124 if (header.pcs_len == 0) {
125 fatal("corrupted coverage file '{f}': pcs_len was zero", .{
126 coverage_file_path,
127 });
128 }
129
130 var seen_count: usize = 0;
131 const chunk_count = fuzz_abi.SeenPcsHeader.seenElemsLen(header.pcs_len);
132 for (0..chunk_count) |_| {
133 const seen = r.interface.takeInt(usize, .little) catch |err| {
134 fatal("failed to read from coverage file '{f}': {s}", .{
135 coverage_file_path, @errorName(err),
136 });
137 };
138 seen_count += @popCount(seen);
139 }
140
141 try server.serveCoverageIdMessage(coverage_id, header.n_runs, header.unique_runs, seen_count);
83 if (builtin.fuzz) {
84 const coverage = fuzz_abi.fuzzer_coverage();
85 try server.serveCoverageIdMessage(
86 coverage.id,
87 coverage.runs,
88 coverage.unique,
89 coverage.seen,
90 );
14291 }
14392
14493 while (true) {
......@@ -235,7 +184,7 @@ fn mainServer(opt_cache_dir: ?[]const u8) !void {
235184 if (@errorReturnTrace()) |trace| {
236185 std.debug.dumpStackTrace(trace.*);
237186 }
238 std.debug.print("failed with error.{s}\n", .{@errorName(err)});
187 std.debug.print("failed with error.{t}\n", .{err});
239188 std.process.exit(1);
240189 },
241190 };
......@@ -305,11 +254,11 @@ fn mainTerminal() void {
305254 else => {
306255 fail_count += 1;
307256 if (have_tty) {
308 std.debug.print("{d}/{d} {s}...FAIL ({s})\n", .{
309 i + 1, test_fn_list.len, test_fn.name, @errorName(err),
257 std.debug.print("{d}/{d} {s}...FAIL ({t})\n", .{
258 i + 1, test_fn_list.len, test_fn.name, err,
310259 });
311260 } else {
312 std.debug.print("FAIL ({s})\n", .{@errorName(err)});
261 std.debug.print("FAIL ({t})\n", .{err});
313262 }
314263 if (@errorReturnTrace()) |trace| {
315264 std.debug.dumpStackTrace(trace.*);
......@@ -450,7 +399,7 @@ pub fn fuzz(
450399 else => {
451400 std.debug.lockStdErr();
452401 if (@errorReturnTrace()) |trace| std.debug.dumpStackTrace(trace.*);
453 std.debug.print("failed with error.{s}\n", .{@errorName(err)});
402 std.debug.print("failed with error.{t}\n", .{err});
454403 std.process.exit(1);
455404 },
456405 };
lib/fuzzer.zig+17-2
......@@ -1,5 +1,6 @@
11const builtin = @import("builtin");
22const std = @import("std");
3const fatal = std.process.fatal;
34const mem = std.mem;
45const math = std.math;
56const Allocator = mem.Allocator;
......@@ -105,6 +106,7 @@ const Executable = struct {
105106 const coverage_file_len = @sizeOf(abi.SeenPcsHeader) +
106107 pc_bitset_usizes * @sizeOf(usize) +
107108 pcs.len * @sizeOf(usize);
109
108110 if (populate) {
109111 defer coverage_file.lock(.shared) catch |e| panic(
110112 "failed to demote lock for coverage file '{s}': {t}",
......@@ -581,8 +583,21 @@ export fn fuzzer_init(cache_dir_path: abi.Slice) void {
581583}
582584
583585/// Invalid until `fuzzer_init` is called.
584export fn fuzzer_coverage_id() u64 {
585 return exec.pc_digest;
586export fn fuzzer_coverage() abi.Coverage {
587 const coverage_id = exec.pc_digest;
588 const header: *const abi.SeenPcsHeader = @ptrCast(@volatileCast(exec.shared_seen_pcs.items.ptr));
589
590 var seen_count: usize = 0;
591 for (header.seenBits()) |chunk| {
592 seen_count += @popCount(chunk);
593 }
594
595 return .{
596 .id = coverage_id,
597 .runs = header.n_runs,
598 .unique = header.unique_runs,
599 .seen = seen_count,
600 };
586601}
587602
588603/// fuzzer_init must be called beforehand
lib/std/Build/abi.zig+11-1
......@@ -140,7 +140,7 @@ pub const Rebuild = extern struct {
140140pub const fuzz = struct {
141141 pub const TestOne = *const fn (Slice) callconv(.c) void;
142142 pub extern fn fuzzer_init(cache_dir_path: Slice) void;
143 pub extern fn fuzzer_coverage_id() u64;
143 pub extern fn fuzzer_coverage() Coverage;
144144 pub extern fn fuzzer_init_test(test_one: TestOne, unit_test_name: Slice) void;
145145 pub extern fn fuzzer_new_input(bytes: Slice) void;
146146 pub extern fn fuzzer_main(limit_kind: LimitKind, amount: u64) void;
......@@ -253,6 +253,16 @@ pub const fuzz = struct {
253253 return .{ .locs_len_raw = @bitCast(locs_len) };
254254 }
255255 };
256
257 /// Sent by lib/fuzzer to test_runner to obtain information about the
258 /// active memory mapped input file and cumulative stats about previous
259 /// fuzzing runs.
260 pub const Coverage = extern struct {
261 id: u64,
262 runs: u64,
263 unique: u64,
264 seen: u64,
265 };
256266};
257267
258268/// ABI bits specifically relating to the time report interface.
test/standalone/libfuzzer/main.zig+1-1
......@@ -24,7 +24,7 @@ pub fn main() !void {
2424 abi.fuzzer_new_input(.fromSlice(""));
2525 abi.fuzzer_new_input(.fromSlice("hello"));
2626
27 const pc_digest = abi.fuzzer_coverage_id();
27 const pc_digest = abi.fuzzer_coverage().id;
2828 const coverage_file_path = "v/" ++ std.fmt.hex(pc_digest);
2929 const coverage_file = try cache_dir.openFile(coverage_file_path, .{});
3030 defer coverage_file.close();