Commit e0dc2e4e3ffe72e5e637e30bdf1d2c59b56f3cb6 | zig

lib/compiler/build_runner.zig+88-6

...	...	@@ -112,7 +112,7 @@ pub fn main() !void {
112	112	var steps_menu = false;
113	113	var output_tmp_nonce: ?[16]u8 = null;
114	114	var watch = false;
115		var fuzz = false;
	115	var fuzz: ?std.Build.Fuzz.Mode = null;
116	116	var debounce_interval_ms: u16 = 50;
117	117	var webui_listen: ?std.net.Address = null;
118	118
...	...	@@ -274,10 +274,44 @@ pub fn main() !void {
274	274	webui_listen = std.net.Address.parseIp("::1", 0) catch unreachable;
275	275	}
276	276	} else if (mem.eql(u8, arg, "--fuzz")) {
277		fuzz = true;
	277	fuzz = .{ .forever = undefined };
278	278	if (webui_listen == null) {
279	279	webui_listen = std.net.Address.parseIp("::1", 0) catch unreachable;
280	280	}
	281	} else if (mem.startsWith(u8, arg, "--fuzz=")) {
	282	const value = arg["--fuzz=".len..];
	283	if (value.len == 0) fatal("missing argument to --fuzz", .{});
	284
	285	const unit: u8 = value[value.len - 1];
	286	const digits = switch (unit) {
	287	'0'...'9' => value,
	288	'K', 'M', 'G' => value[0 .. value.len - 1],
	289	else => fatal(
	290	"invalid argument to --fuzz, expected a positive number optionally suffixed by one of: [KMG]",
	291	.{},
	292	),
	293	};
	294
	295	const amount = std.fmt.parseInt(u64, digits, 10) catch {
	296	fatal(
	297	"invalid argument to --fuzz, expected a positive number optionally suffixed by one of: [KMG]",
	298	.{},
	299	);
	300	};
	301
	302	const normalized_amount = std.math.mul(u64, amount, switch (unit) {
	303	else => unreachable,
	304	'0'...'9' => 1,
	305	'K' => 1000,
	306	'M' => 1_000_000,
	307	'G' => 1_000_000_000,
	308	}) catch fatal("fuzzing limit amount overflows u64", .{});
	309
	310	fuzz = .{
	311	.limit = .{
	312	.amount = normalized_amount,
	313	},
	314	};
281	315	} else if (mem.eql(u8, arg, "-fincremental")) {
282	316	graph.incremental = true;
283	317	} else if (mem.eql(u8, arg, "-fno-incremental")) {
...	...	@@ -476,6 +510,7 @@ pub fn main() !void {
476	510	targets.items,
477	511	main_progress_node,
478	512	&run,
	513	fuzz,
479	514	) catch \|err\| switch (err) {
480	515	error.UncleanExit => {
481	516	assert(!run.watch and run.web_server == null);
...	...	@@ -485,7 +520,12 @@ pub fn main() !void {
485	520	};
486	521
487	522	if (run.web_server) \|*web_server\| {
488		web_server.finishBuild(.{ .fuzz = fuzz });
	523	if (fuzz) \|mode\| if (mode != .forever) fatal(
	524	"error: limited fuzzing is not implemented yet for --webui",
	525	.{},
	526	);
	527
	528	web_server.finishBuild(.{ .fuzz = fuzz != null });
489	529	}
490	530
491	531	if (!watch and run.web_server == null) {
...	...	@@ -651,6 +691,7 @@ fn runStepNames(
651	691	step_names: []const []const u8,
652	692	parent_prog_node: std.Progress.Node,
653	693	run: *Run,
	694	fuzz: ?std.Build.Fuzz.Mode,
654	695	) !void {
655	696	const gpa = run.gpa;
656	697	const step_stack = &run.step_stack;
...	...	@@ -676,6 +717,7 @@ fn runStepNames(
676	717	});
677	718	}
678	719	}
	720
679	721	assert(run.memory_blocked_steps.items.len == 0);
680	722
681	723	var test_skip_count: usize = 0;
...	...	@@ -724,6 +766,45 @@ fn runStepNames(
724	766	}
725	767	}
726	768
	769	const ttyconf = run.ttyconf;
	770
	771	if (fuzz) \|mode\| blk: {
	772	switch (builtin.os.tag) {
	773	// Current implementation depends on two things that need to be ported to Windows:
	774	// * Memory-mapping to share data between the fuzzer and build runner.
	775	// * COFF/PE support added to `std.debug.Info` (it needs a batching API for resolving
	776	// many addresses to source locations).
	777	.windows => fatal("--fuzz not yet implemented for {s}", .{@tagName(builtin.os.tag)}),
	778	else => {},
	779	}
	780	if (@bitSizeOf(usize) != 64) {
	781	// Current implementation depends on posix.mmap()'s second parameter, `length: usize`,
	782	// being compatible with `std.fs.getEndPos() u64`'s return value. This is not the case
	783	// on 32-bit platforms.
	784	// Affects or affected by issues #5185, #22523, and #22464.
	785	fatal("--fuzz not yet implemented on {d}-bit platforms", .{@bitSizeOf(usize)});
	786	}
	787
	788	switch (mode) {
	789	.forever => break :blk,
	790	.limit => {},
	791	}
	792
	793	assert(mode == .limit);
	794	var f = std.Build.Fuzz.init(
	795	gpa,
	796	thread_pool,
	797	step_stack.keys(),
	798	parent_prog_node,
	799	ttyconf,
	800	mode,
	801	) catch \|err\| fatal("failed to start fuzzer: {s}", .{@errorName(err)});
	802	defer f.deinit();
	803
	804	f.start();
	805	f.waitAndPrintReport();
	806	}
	807
727	808	// A proper command line application defaults to silently succeeding.
728	809	// The user may request verbose mode if they have a different preference.
729	810	const failures_only = switch (run.summary) {
...	...	@@ -737,8 +818,6 @@ fn runStepNames(
737	818	std.Progress.setStatus(.failure);
738	819	}
739	820
740		const ttyconf = run.ttyconf;
741
742	821	if (run.summary != .none) {
743	822	const w = std.debug.lockStderrWriter(&stdio_buffer_allocation);
744	823	defer std.debug.unlockStderrWriter();
...	...	@@ -1366,7 +1445,10 @@ fn printUsage(b: std.Build, w: Writer) !void {
1366	1445	\\ --watch Continuously rebuild when source files are modified
1367	1446	\\ --debounce <ms> Delay before rebuilding after changed file detected
1368	1447	\\ --webui[=ip] Enable the web interface on the given IP address
1369		\\ --fuzz Continuously search for unit test failures (implies '--webui')
	1448	\\ --fuzz[=limit] Continuously search for unit test failures with an optional
	1449	\\ limit to the max number of iterations. The argument supports
	1450	\\ an optional 'K', 'M', or 'G' suffix (e.g. '10K'). Implies
	1451	\\ '--webui' when no limit is specified.
1370	1452	\\ --time-report Force full rebuild and provide detailed information on
1371	1453	\\ compilation time of Zig source code (implies '--webui')
1372	1454	\\ -fincremental Enable incremental compilation

lib/compiler/test_runner.zig+27-9

...	...	@@ -2,6 +2,7 @@
2	2	const builtin = @import("builtin");
3	3
4	4	const std = @import("std");
	5	const fatal = std.process.fatal;
5	6	const testing = std.testing;
6	7	const assert = std.debug.assert;
7	8	const fuzz_abi = std.Build.abi.fuzz;
...	...	@@ -55,12 +56,13 @@ pub fn main() void {
55	56	}
56	57	}
57	58
58		fba.reset();
59	59	if (builtin.fuzz) {
60	60	const cache_dir = opt_cache_dir orelse @panic("missing --cache-dir=[path] argument");
61	61	fuzz_abi.fuzzer_init(.fromSlice(cache_dir));
62	62	}
63	63
	64	fba.reset();
	65
64	66	if (listen) {
65	67	return mainServer() catch @panic("internal test runner failure");
66	68	} else {
...	...	@@ -79,8 +81,13 @@ fn mainServer() !void {
79	81	});
80	82
81	83	if (builtin.fuzz) {
82		const coverage_id = fuzz_abi.fuzzer_coverage_id();
83		try server.serveU64Message(.coverage_id, coverage_id);
	84	const coverage = fuzz_abi.fuzzer_coverage();
	85	try server.serveCoverageIdMessage(
	86	coverage.id,
	87	coverage.runs,
	88	coverage.unique,
	89	coverage.seen,
	90	);
84	91	}
85	92
86	93	while (true) {
...	...	@@ -158,6 +165,9 @@ fn mainServer() !void {
158	165	if (!builtin.fuzz) unreachable;
159	166
160	167	const index = try server.receiveBody_u32();
	168	const mode: fuzz_abi.LimitKind = @enumFromInt(try server.receiveBody_u8());
	169	const amount_or_instance = try server.receiveBody_u64();
	170
161	171	const test_fn = builtin.test_functions[index];
162	172	const entry_addr = @intFromPtr(test_fn.func);
163	173
...	...	@@ -165,6 +175,8 @@ fn mainServer() !void {
165	175	defer if (testing.allocator_instance.deinit() == .leak) std.process.exit(1);
166	176	is_fuzz_test = false;
167	177	fuzz_test_index = index;
	178	fuzz_mode = mode;
	179	fuzz_amount_or_instance = amount_or_instance;
168	180
169	181	test_fn.func() catch \|err\| switch (err) {
170	182	error.SkipZigTest => return,
...	...	@@ -172,12 +184,14 @@ fn mainServer() !void {
172	184	if (@errorReturnTrace()) \|trace\| {
173	185	std.debug.dumpStackTrace(trace.*);
174	186	}
175		std.debug.print("failed with error.{s}\n", .{@errorName(err)});
	187	std.debug.print("failed with error.{t}\n", .{err});
176	188	std.process.exit(1);
177	189	},
178	190	};
179	191	if (!is_fuzz_test) @panic("missed call to std.testing.fuzz");
180	192	if (log_err_count != 0) @panic("error logs detected");
	193	assert(mode != .forever);
	194	std.process.exit(0);
181	195	},
182	196
183	197	else => {
...	...	@@ -240,11 +254,11 @@ fn mainTerminal() void {
240	254	else => {
241	255	fail_count += 1;
242	256	if (have_tty) {
243		std.debug.print("{d}/{d} {s}...FAIL ({s})\n", .{
244		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,
245	259	});
246	260	} else {
247		std.debug.print("FAIL ({s})\n", .{@errorName(err)});
	261	std.debug.print("FAIL ({t})\n", .{err});
248	262	}
249	263	if (@errorReturnTrace()) \|trace\| {
250	264	std.debug.dumpStackTrace(trace.*);
...	...	@@ -343,6 +357,8 @@ pub fn mainSimple() anyerror!void {
343	357
344	358	var is_fuzz_test: bool = undefined;
345	359	var fuzz_test_index: u32 = undefined;
	360	var fuzz_mode: fuzz_abi.LimitKind = undefined;
	361	var fuzz_amount_or_instance: u64 = undefined;
346	362
347	363	pub fn fuzz(
348	364	context: anytype,
...	...	@@ -383,7 +399,7 @@ pub fn fuzz(
383	399	else => {
384	400	std.debug.lockStdErr();
385	401	if (@errorReturnTrace()) \|trace\| std.debug.dumpStackTrace(trace.*);
386		std.debug.print("failed with error.{s}\n", .{@errorName(err)});
	402	std.debug.print("failed with error.{t}\n", .{err});
387	403	std.process.exit(1);
388	404	},
389	405	};
...	...	@@ -401,9 +417,11 @@ pub fn fuzz(
401	417
402	418	global.ctx = context;
403	419	fuzz_abi.fuzzer_init_test(&global.test_one, .fromSlice(builtin.test_functions[fuzz_test_index].name));
	420
404	421	for (options.corpus) \|elem\|
405	422	fuzz_abi.fuzzer_new_input(.fromSlice(elem));
406		fuzz_abi.fuzzer_main();
	423
	424	fuzz_abi.fuzzer_main(fuzz_mode, fuzz_amount_or_instance);
407	425	return;
408	426	}
409	427

lib/fuzzer.zig+64-48

...	...	@@ -1,5 +1,6 @@
1	1	const builtin = @import("builtin");
2	2	const std = @import("std");
	3	const fatal = std.process.fatal;
3	4	const mem = std.mem;
4	5	const math = std.math;
5	6	const Allocator = mem.Allocator;
...	...	@@ -105,6 +106,7 @@ const Executable = struct {
105	106	const coverage_file_len = @sizeOf(abi.SeenPcsHeader) +
106	107	pc_bitset_usizes * @sizeOf(usize) +
107	108	pcs.len * @sizeOf(usize);
	109
108	110	if (populate) {
109	111	defer coverage_file.lock(.shared) catch \|e\| panic(
110	112	"failed to demote lock for coverage file '{s}': {t}",
...	...	@@ -510,7 +512,7 @@ const Fuzzer = struct {
510	512	self.corpus_pos = 0;
511	513
512	514	const rng = self.rng.random();
513		while (true) {
	515	const m = while (true) {
514	516	const m = self.mutations.items[rng.uintLessThanBiased(usize, self.mutations.items.len)];
515	517	if (!m.mutate(
516	518	rng,
...	...	@@ -522,53 +524,53 @@ const Fuzzer = struct {
522	524	inst.const_vals8.items,
523	525	inst.const_vals16.items,
524	526	)) continue;
	527	break m;
	528	};
525	529
526		self.run();
527		if (inst.isFresh()) {
528		@branchHint(.unlikely);
529
530		const header = mem.bytesAsValue(
531		abi.SeenPcsHeader,
532		exec.shared_seen_pcs.items[0..@sizeOf(abi.SeenPcsHeader)],
533		);
534		_ = @atomicRmw(usize, &header.unique_runs, .Add, 1, .monotonic);
	530	self.run();
535	531
536		inst.setFresh();
537		self.minimizeInput();
538		inst.updateSeen();
539
540		// An empty-input has always been tried, so if an empty input is fresh then the
541		// test has to be non-deterministic. This has to be checked as duplicate empty
542		// entries are not allowed.
543		if (self.input.items.len - 8 == 0) {
544		std.log.warn("non-deterministic test (empty input produces different hits)", .{});
545		_ = @atomicRmw(usize, &header.unique_runs, .Sub, 1, .monotonic);
546		return;
547		}
	532	if (inst.isFresh()) {
	533	@branchHint(.unlikely);
548	534
549		const arena = self.arena_ctx.allocator();
550		const bytes = arena.dupe(u8, @volatileCast(self.input.items[8..])) catch @panic("OOM");
551
552		self.corpus.append(gpa, bytes) catch @panic("OOM");
553		self.mutations.appendNTimes(gpa, m, 6) catch @panic("OOM");
554
555		// Write new corpus to cache
556		var name_buf: [@sizeOf(usize) * 2]u8 = undefined;
557		self.corpus_dir.writeFile(.{
558		.sub_path = std.fmt.bufPrint(
559		&name_buf,
560		"{x}",
561		.{self.corpus_dir_idx},
562		) catch unreachable,
563		.data = bytes,
564		}) catch \|e\| panic(
565		"failed to write corpus file '{x}': {t}",
566		.{ self.corpus_dir_idx, e },
567		);
568		self.corpus_dir_idx += 1;
	535	const header = mem.bytesAsValue(
	536	abi.SeenPcsHeader,
	537	exec.shared_seen_pcs.items[0..@sizeOf(abi.SeenPcsHeader)],
	538	);
	539	_ = @atomicRmw(usize, &header.unique_runs, .Add, 1, .monotonic);
	540
	541	inst.setFresh();
	542	self.minimizeInput();
	543	inst.updateSeen();
	544
	545	// An empty-input has always been tried, so if an empty input is fresh then the
	546	// test has to be non-deterministic. This has to be checked as duplicate empty
	547	// entries are not allowed.
	548	if (self.input.items.len - 8 == 0) {
	549	std.log.warn("non-deterministic test (empty input produces different hits)", .{});
	550	_ = @atomicRmw(usize, &header.unique_runs, .Sub, 1, .monotonic);
	551	return;
569	552	}
570	553
571		break;
	554	const arena = self.arena_ctx.allocator();
	555	const bytes = arena.dupe(u8, @volatileCast(self.input.items[8..])) catch @panic("OOM");
	556
	557	self.corpus.append(gpa, bytes) catch @panic("OOM");
	558	self.mutations.appendNTimes(gpa, m, 6) catch @panic("OOM");
	559
	560	// Write new corpus to cache
	561	var name_buf: [@sizeOf(usize) * 2]u8 = undefined;
	562	self.corpus_dir.writeFile(.{
	563	.sub_path = std.fmt.bufPrint(
	564	&name_buf,
	565	"{x}",
	566	.{self.corpus_dir_idx},
	567	) catch unreachable,
	568	.data = bytes,
	569	}) catch \|e\| panic(
	570	"failed to write corpus file '{x}': {t}",
	571	.{ self.corpus_dir_idx, e },
	572	);
	573	self.corpus_dir_idx += 1;
572	574	}
573	575	}
574	576	};
...	...	@@ -581,8 +583,21 @@ export fn fuzzer_init(cache_dir_path: abi.Slice) void {
581	583	}
582	584
583	585	/// Invalid until `fuzzer_init` is called.
584		export fn fuzzer_coverage_id() u64 {
585		return exec.pc_digest;
	586	export 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	};
586	601	}
587	602
588	603	/// fuzzer_init must be called beforehand
...	...	@@ -600,9 +615,10 @@ export fn fuzzer_new_input(bytes: abi.Slice) void {
600	615	}
601	616
602	617	/// fuzzer_init_test must be called first
603		export fn fuzzer_main() void {
604		while (true) {
605		fuzzer.cycle();
	618	export fn fuzzer_main(limit_kind: abi.LimitKind, amount: u64) void {
	619	switch (limit_kind) {
	620	.forever => while (true) fuzzer.cycle(),
	621	.iterations => for (0..amount) \|_\| fuzzer.cycle(),
606	622	}
607	623	}
608	624

lib/std/Build/Fuzz.zig+162-44

...	...	@@ -8,17 +8,22 @@ const Allocator = std.mem.Allocator;
8	8	const log = std.log;
9	9	const Coverage = std.debug.Coverage;
10	10	const abi = Build.abi.fuzz;
	11	const tty = std.Io.tty;
11	12
12	13	const Fuzz = @This();
13	14	const build_runner = @import("root");
14	15
15		ws: *Build.WebServer,
	16	gpa: Allocator,
	17	mode: Mode,
16	18
17		/// Allocated into `ws.gpa`.
	19	/// Allocated into `gpa`.
18	20	run_steps: []const *Step.Run,
19	21
20	22	wait_group: std.Thread.WaitGroup,
	23	root_prog_node: std.Progress.Node,
21	24	prog_node: std.Progress.Node,
	25	thread_pool: *std.Thread.Pool,
	26	ttyconf: tty.Config,
22	27
23	28	/// Protects `coverage_files`.
24	29	coverage_mutex: std.Thread.Mutex,
...	...	@@ -28,9 +33,23 @@ queue_mutex: std.Thread.Mutex,
28	33	queue_cond: std.Thread.Condition,
29	34	msg_queue: std.ArrayListUnmanaged(Msg),
30	35
	36	pub const Mode = union(enum) {
	37	forever: struct { ws: *Build.WebServer },
	38	limit: Limited,
	39
	40	pub const Limited = struct {
	41	amount: u64,
	42	};
	43	};
	44
31	45	const Msg = union(enum) {
32	46	coverage: struct {
33	47	id: u64,
	48	cumulative: struct {
	49	runs: u64,
	50	unique: u64,
	51	coverage: u64,
	52	},
34	53	run: *Step.Run,
35	54	},
36	55	entry_point: struct {
...	...	@@ -54,23 +73,28 @@ const CoverageMap = struct {
54	73	}
55	74	};
56	75
57		pub fn init(ws: *Build.WebServer) Allocator.Error!Fuzz {
58		const gpa = ws.gpa;
59
	76	pub fn init(
	77	gpa: Allocator,
	78	thread_pool: *std.Thread.Pool,
	79	all_steps: []const *Build.Step,
	80	root_prog_node: std.Progress.Node,
	81	ttyconf: tty.Config,
	82	mode: Mode,
	83	) Allocator.Error!Fuzz {
60	84	const run_steps: []const *Step.Run = steps: {
61	85	var steps: std.ArrayListUnmanaged(*Step.Run) = .empty;
62	86	defer steps.deinit(gpa);
63		const rebuild_node = ws.root_prog_node.start("Rebuilding Unit Tests", 0);
	87	const rebuild_node = root_prog_node.start("Rebuilding Unit Tests", 0);
64	88	defer rebuild_node.end();
65	89	var rebuild_wg: std.Thread.WaitGroup = .{};
66	90	defer rebuild_wg.wait();
67	91
68		for (ws.all_steps) \|step\| {
	92	for (all_steps) \|step\| {
69	93	const run = step.cast(Step.Run) orelse continue;
70	94	if (run.producer == null) continue;
71	95	if (run.fuzz_tests.items.len == 0) continue;
72	96	try steps.append(gpa, run);
73		ws.thread_pool.spawnWg(&rebuild_wg, rebuildTestsWorkerRun, .{ run, gpa, ws.ttyconf, rebuild_node });
	97	thread_pool.spawnWg(&rebuild_wg, rebuildTestsWorkerRun, .{ run, gpa, ttyconf, rebuild_node });
74	98	}
75	99
76	100	if (steps.items.len == 0) fatal("no fuzz tests found", .{});
...	...	@@ -86,9 +110,13 @@ pub fn init(ws: *Build.WebServer) Allocator.Error!Fuzz {
86	110	}
87	111
88	112	return .{
89		.ws = ws,
	113	.gpa = gpa,
	114	.mode = mode,
90	115	.run_steps = run_steps,
91	116	.wait_group = .{},
	117	.thread_pool = thread_pool,
	118	.ttyconf = ttyconf,
	119	.root_prog_node = root_prog_node,
92	120	.prog_node = .none,
93	121	.coverage_files = .empty,
94	122	.coverage_mutex = .{},
...	...	@@ -99,32 +127,31 @@ pub fn init(ws: *Build.WebServer) Allocator.Error!Fuzz {
99	127	}
100	128
101	129	pub fn start(fuzz: *Fuzz) void {
102		const ws = fuzz.ws;
103		fuzz.prog_node = ws.root_prog_node.start("Fuzzing", fuzz.run_steps.len);
104
105		// For polling messages and sending updates to subscribers.
106		fuzz.wait_group.start();
107		_ = std.Thread.spawn(.{}, coverageRun, .{fuzz}) catch \|err\| {
108		fuzz.wait_group.finish();
109		fatal("unable to spawn coverage thread: {s}", .{@errorName(err)});
110		};
	130	fuzz.prog_node = fuzz.root_prog_node.start("Fuzzing", fuzz.run_steps.len);
	131
	132	if (fuzz.mode == .forever) {
	133	// For polling messages and sending updates to subscribers.
	134	fuzz.wait_group.start();
	135	_ = std.Thread.spawn(.{}, coverageRun, .{fuzz}) catch \|err\| {
	136	fuzz.wait_group.finish();
	137	fatal("unable to spawn coverage thread: {s}", .{@errorName(err)});
	138	};
	139	}
111	140
112	141	for (fuzz.run_steps) \|run\| {
113	142	for (run.fuzz_tests.items) \|unit_test_index\| {
114	143	assert(run.rebuilt_executable != null);
115		ws.thread_pool.spawnWg(&fuzz.wait_group, fuzzWorkerRun, .{
	144	fuzz.thread_pool.spawnWg(&fuzz.wait_group, fuzzWorkerRun, .{
116	145	fuzz, run, unit_test_index,
117	146	});
118	147	}
119	148	}
120	149	}
	150
121	151	pub fn deinit(fuzz: *Fuzz) void {
122		if (true) @panic("TODO: terminate the fuzzer processes");
123		fuzz.wait_group.wait();
	152	if (!fuzz.wait_group.isDone()) @panic("TODO: terminate the fuzzer processes");
124	153	fuzz.prog_node.end();
125
126		const gpa = fuzz.ws.gpa;
127		gpa.free(fuzz.run_steps);
	154	fuzz.gpa.free(fuzz.run_steps);
128	155	}
129	156
130	157	fn rebuildTestsWorkerRun(run: *Step.Run, gpa: Allocator, ttyconf: std.Io.tty.Config, parent_prog_node: std.Progress.Node) void {
...	...	@@ -177,7 +204,7 @@ fn fuzzWorkerRun(
177	204	var buf: [256]u8 = undefined;
178	205	const w = std.debug.lockStderrWriter(&buf);
179	206	defer std.debug.unlockStderrWriter();
180		build_runner.printErrorMessages(gpa, &run.step, .{ .ttyconf = fuzz.ws.ttyconf }, w, false) catch {};
	207	build_runner.printErrorMessages(gpa, &run.step, .{ .ttyconf = fuzz.ttyconf }, w, false) catch {};
181	208	return;
182	209	},
183	210	else => {
...	...	@@ -190,20 +217,20 @@ fn fuzzWorkerRun(
190	217	}
191	218
192	219	pub fn serveSourcesTar(fuzz: Fuzz, req: std.http.Server.Request) !void {
193		const gpa = fuzz.ws.gpa;
	220	assert(fuzz.mode == .forever);
194	221
195		var arena_state: std.heap.ArenaAllocator = .init(gpa);
	222	var arena_state: std.heap.ArenaAllocator = .init(fuzz.gpa);
196	223	defer arena_state.deinit();
197	224	const arena = arena_state.allocator();
198	225
199	226	const DedupTable = std.ArrayHashMapUnmanaged(Build.Cache.Path, void, Build.Cache.Path.TableAdapter, false);
200	227	var dedup_table: DedupTable = .empty;
201		defer dedup_table.deinit(gpa);
	228	defer dedup_table.deinit(fuzz.gpa);
202	229
203	230	for (fuzz.run_steps) \|run_step\| {
204	231	const compile_inputs = run_step.producer.?.step.inputs.table;
205	232	for (compile_inputs.keys(), compile_inputs.values()) \|dir_path, *file_list\| {
206		try dedup_table.ensureUnusedCapacity(gpa, file_list.items.len);
	233	try dedup_table.ensureUnusedCapacity(fuzz.gpa, file_list.items.len);
207	234	for (file_list.items) \|sub_path\| {
208	235	if (!std.mem.endsWith(u8, sub_path, ".zig")) continue;
209	236	const joined_path = try dir_path.join(arena, sub_path);
...	...	@@ -224,13 +251,18 @@ pub fn serveSourcesTar(fuzz: Fuzz, req: std.http.Server.Request) !void {
224	251	}
225	252	};
226	253	std.mem.sortUnstable(Build.Cache.Path, deduped_paths, SortContext{}, SortContext.lessThan);
227		return fuzz.ws.serveTarFile(req, deduped_paths);
	254	return fuzz.mode.forever.ws.serveTarFile(req, deduped_paths);
228	255	}
229	256
230	257	pub const Previous = struct {
231	258	unique_runs: usize,
232	259	entry_points: usize,
233		pub const init: Previous = .{ .unique_runs = 0, .entry_points = 0 };
	260	sent_source_index: bool,
	261	pub const init: Previous = .{
	262	.unique_runs = 0,
	263	.entry_points = 0,
	264	.sent_source_index = false,
	265	};
234	266	};
235	267	pub fn sendUpdate(
236	268	fuzz: *Fuzz,
...	...	@@ -253,7 +285,8 @@ pub fn sendUpdate(
253	285	const n_runs = @atomicLoad(usize, &cov_header.n_runs, .monotonic);
254	286	const unique_runs = @atomicLoad(usize, &cov_header.unique_runs, .monotonic);
255	287	{
256		if (unique_runs != 0 and prev.unique_runs == 0) {
	288	if (!prev.sent_source_index) {
	289	prev.sent_source_index = true;
257	290	// We need to send initial context.
258	291	const header: abi.SourceIndexHeader = .{
259	292	.directories_len = @intCast(coverage_map.coverage.directories.entries.len),
...	...	@@ -319,13 +352,13 @@ fn coverageRun(fuzz: *Fuzz) void {
319	352	}
320	353	}
321	354	fn prepareTables(fuzz: Fuzz, run_step: Step.Run, coverage_id: u64) error{ OutOfMemory, AlreadyReported }!void {
322		const ws = fuzz.ws;
323		const gpa = ws.gpa;
	355	assert(fuzz.mode == .forever);
	356	const ws = fuzz.mode.forever.ws;
324	357
325	358	fuzz.coverage_mutex.lock();
326	359	defer fuzz.coverage_mutex.unlock();
327	360
328		const gop = try fuzz.coverage_files.getOrPut(gpa, coverage_id);
	361	const gop = try fuzz.coverage_files.getOrPut(fuzz.gpa, coverage_id);
329	362	if (gop.found_existing) {
330	363	// We are fuzzing the same executable with multiple threads.
331	364	// Perhaps the same unit test; perhaps a different one. In any
...	...	@@ -343,16 +376,16 @@ fn prepareTables(fuzz: Fuzz, run_step: Step.Run, coverage_id: u64) error{ OutO
343	376	.entry_points = .{},
344	377	.start_timestamp = ws.now(),
345	378	};
346		errdefer gop.value_ptr.coverage.deinit(gpa);
	379	errdefer gop.value_ptr.coverage.deinit(fuzz.gpa);
347	380
348	381	const rebuilt_exe_path = run_step.rebuilt_executable.?;
349		var debug_info = std.debug.Info.load(gpa, rebuilt_exe_path, &gop.value_ptr.coverage) catch \|err\| {
	382	var debug_info = std.debug.Info.load(fuzz.gpa, rebuilt_exe_path, &gop.value_ptr.coverage) catch \|err\| {
350	383	log.err("step '{s}': failed to load debug information for '{f}': {s}", .{
351	384	run_step.step.name, rebuilt_exe_path, @errorName(err),
352	385	});
353	386	return error.AlreadyReported;
354	387	};
355		defer debug_info.deinit(gpa);
	388	defer debug_info.deinit(fuzz.gpa);
356	389
357	390	const coverage_file_path: Build.Cache.Path = .{
358	391	.root_dir = run_step.step.owner.cache_root,
...	...	@@ -386,14 +419,14 @@ fn prepareTables(fuzz: Fuzz, run_step: Step.Run, coverage_id: u64) error{ OutO
386	419
387	420	const header: *const abi.SeenPcsHeader = @ptrCast(mapped_memory[0..@sizeOf(abi.SeenPcsHeader)]);
388	421	const pcs = header.pcAddrs();
389		const source_locations = try gpa.alloc(Coverage.SourceLocation, pcs.len);
390		errdefer gpa.free(source_locations);
	422	const source_locations = try fuzz.gpa.alloc(Coverage.SourceLocation, pcs.len);
	423	errdefer fuzz.gpa.free(source_locations);
391	424
392	425	// Unfortunately the PCs array that LLVM gives us from the 8-bit PC
393	426	// counters feature is not sorted.
394	427	var sorted_pcs: std.MultiArrayList(struct { pc: u64, index: u32, sl: Coverage.SourceLocation }) = .{};
395		defer sorted_pcs.deinit(gpa);
396		try sorted_pcs.resize(gpa, pcs.len);
	428	defer sorted_pcs.deinit(fuzz.gpa);
	429	try sorted_pcs.resize(fuzz.gpa, pcs.len);
397	430	@memcpy(sorted_pcs.items(.pc), pcs);
398	431	for (sorted_pcs.items(.index), 0..) \|v, i\| v. = @intCast(i);
399	432	sorted_pcs.sortUnstable(struct {
...	...	@@ -404,7 +437,7 @@ fn prepareTables(fuzz: Fuzz, run_step: Step.Run, coverage_id: u64) error{ OutO
404	437	}
405	438	}{ .addrs = sorted_pcs.items(.pc) });
406	439
407		debug_info.resolveAddresses(gpa, sorted_pcs.items(.pc), sorted_pcs.items(.sl)) catch \|err\| {
	440	debug_info.resolveAddresses(fuzz.gpa, sorted_pcs.items(.pc), sorted_pcs.items(.sl)) catch \|err\| {
408	441	log.err("failed to resolve addresses to source locations: {s}", .{@errorName(err)});
409	442	return error.AlreadyReported;
410	443	};
...	...	@@ -414,6 +447,7 @@ fn prepareTables(fuzz: Fuzz, run_step: Step.Run, coverage_id: u64) error{ OutO
414	447
415	448	ws.notifyUpdate();
416	449	}
	450
417	451	fn addEntryPoint(fuzz: *Fuzz, coverage_id: u64, addr: u64) error{ AlreadyReported, OutOfMemory }!void {
418	452	fuzz.coverage_mutex.lock();
419	453	defer fuzz.coverage_mutex.unlock();
...	...	@@ -445,5 +479,89 @@ fn addEntryPoint(fuzz: *Fuzz, coverage_id: u64, addr: u64) error{ AlreadyReporte
445	479	addr, file_name, sl.line, sl.column, index, pcs[index - 1], pcs[index + 1],
446	480	});
447	481	}
448		try coverage_map.entry_points.append(fuzz.ws.gpa, @intCast(index));
	482	try coverage_map.entry_points.append(fuzz.gpa, @intCast(index));
	483	}
	484
	485	pub fn waitAndPrintReport(fuzz: *Fuzz) void {
	486	assert(fuzz.mode == .limit);
	487
	488	fuzz.wait_group.wait();
	489	fuzz.wait_group.reset();
	490
	491	std.debug.print("======= FUZZING REPORT =======\n", .{});
	492	for (fuzz.msg_queue.items) \|msg\| {
	493	if (msg != .coverage) continue;
	494
	495	const cov = msg.coverage;
	496	const coverage_file_path: std.Build.Cache.Path = .{
	497	.root_dir = cov.run.step.owner.cache_root,
	498	.sub_path = "v/" ++ std.fmt.hex(cov.id),
	499	};
	500	var coverage_file = coverage_file_path.root_dir.handle.openFile(coverage_file_path.sub_path, .{}) catch \|err\| {
	501	fatal("step '{s}': failed to load coverage file '{f}': {s}", .{
	502	cov.run.step.name, coverage_file_path, @errorName(err),
	503	});
	504	};
	505	defer coverage_file.close();
	506
	507	const fuzz_abi = std.Build.abi.fuzz;
	508	var rbuf: [0x1000]u8 = undefined;
	509	var r = coverage_file.reader(&rbuf);
	510
	511	var header: fuzz_abi.SeenPcsHeader = undefined;
	512	r.interface.readSliceAll(std.mem.asBytes(&header)) catch \|err\| {
	513	fatal("step '{s}': failed to read from coverage file '{f}': {s}", .{
	514	cov.run.step.name, coverage_file_path, @errorName(err),
	515	});
	516	};
	517
	518	if (header.pcs_len == 0) {
	519	fatal("step '{s}': corrupted coverage file '{f}': pcs_len was zero", .{
	520	cov.run.step.name, coverage_file_path,
	521	});
	522	}
	523
	524	var seen_count: usize = 0;
	525	const chunk_count = fuzz_abi.SeenPcsHeader.seenElemsLen(header.pcs_len);
	526	for (0..chunk_count) \|_\| {
	527	const seen = r.interface.takeInt(usize, .little) catch \|err\| {
	528	fatal("step '{s}': failed to read from coverage file '{f}': {s}", .{
	529	cov.run.step.name, coverage_file_path, @errorName(err),
	530	});
	531	};
	532	seen_count += @popCount(seen);
	533	}
	534
	535	const seen_f: f64 = @floatFromInt(seen_count);
	536	const total_f: f64 = @floatFromInt(header.pcs_len);
	537	const ratio = seen_f / total_f;
	538	std.debug.print(
	539	\\Step: {s}
	540	\\Fuzz test: "{s}" ({x})
	541	\\Runs: {} -> {}
	542	\\Unique runs: {} -> {}
	543	\\Coverage: {}/{} -> {}/{} ({:.02}%)
	544	\\
	545	, .{
	546	cov.run.step.name,
	547	cov.run.cached_test_metadata.?.testName(cov.run.fuzz_tests.items[0]),
	548	cov.id,
	549	cov.cumulative.runs,
	550	header.n_runs,
	551	cov.cumulative.unique,
	552	header.unique_runs,
	553	cov.cumulative.coverage,
	554	header.pcs_len,
	555	seen_count,
	556	header.pcs_len,
	557	ratio * 100,
	558	});
	559
	560	std.debug.print("------------------------------\n", .{});
	561	}
	562	std.debug.print(
	563	\\Values are accumulated across multiple runs when preserving the cache.
	564	\\==============================
	565	\\
	566	, .{});
449	567	}

lib/std/Build/Step/Run.zig+43-10

...	...	@@ -1662,12 +1662,24 @@ fn evalZigTest(
1662	1662	// If this is `true`, we avoid ever entering the polling loop below, because the stdin pipe has
1663	1663	// somehow already closed; instead, we go straight to capturing stderr in case it has anything
1664	1664	// useful.
1665		const first_write_failed = if (fuzz_context) \|fuzz\| failed: {
1666		sendRunTestMessage(child.stdin.?, .start_fuzzing, fuzz.unit_test_index) catch \|err\| {
1667		try run.step.addError("unable to write stdin: {s}", .{@errorName(err)});
1668		break :failed true;
1669		};
1670		break :failed false;
	1665	const first_write_failed = if (fuzz_context) \|fctx\| failed: {
	1666	switch (fctx.fuzz.mode) {
	1667	.forever => {
	1668	const instance_id = 0; // will be used by mutiprocess forever fuzzing
	1669	sendRunFuzzTestMessage(child.stdin.?, fctx.unit_test_index, .forever, instance_id) catch \|err\| {
	1670	try run.step.addError("unable to write stdin: {s}", .{@errorName(err)});
	1671	break :failed true;
	1672	};
	1673	break :failed false;
	1674	},
	1675	.limit => \|limit\| {
	1676	sendRunFuzzTestMessage(child.stdin.?, fctx.unit_test_index, .iterations, limit.amount) catch \|err\| {
	1677	try run.step.addError("unable to write stdin: {s}", .{@errorName(err)});
	1678	break :failed true;
	1679	};
	1680	break :failed false;
	1681	},
	1682	}
1671	1683	} else failed: {
1672	1684	run.fuzz_tests.clearRetainingCapacity();
1673	1685	sendMessage(child.stdin.?, .query_test_metadata) catch \|err\| {
...	...	@@ -1778,13 +1790,18 @@ fn evalZigTest(
1778	1790	},
1779	1791	.coverage_id => {
1780	1792	const fuzz = fuzz_context.?.fuzz;
1781		const msg_ptr: *align(1) const u64 = @ptrCast(body);
1782		coverage_id = msg_ptr.*;
	1793	const msg_ptr: *align(1) const [4]u64 = @ptrCast(body);
	1794	coverage_id = msg_ptr[0];
1783	1795	{
1784	1796	fuzz.queue_mutex.lock();
1785	1797	defer fuzz.queue_mutex.unlock();
1786		try fuzz.msg_queue.append(fuzz.ws.gpa, .{ .coverage = .{
	1798	try fuzz.msg_queue.append(fuzz.gpa, .{ .coverage = .{
1787	1799	.id = coverage_id.?,
	1800	.cumulative = .{
	1801	.runs = msg_ptr[1],
	1802	.unique = msg_ptr[2],
	1803	.coverage = msg_ptr[3],
	1804	},
1788	1805	.run = run,
1789	1806	} });
1790	1807	fuzz.queue_cond.signal();
...	...	@@ -1797,7 +1814,7 @@ fn evalZigTest(
1797	1814	{
1798	1815	fuzz.queue_mutex.lock();
1799	1816	defer fuzz.queue_mutex.unlock();
1800		try fuzz.msg_queue.append(fuzz.ws.gpa, .{ .entry_point = .{
	1817	try fuzz.msg_queue.append(fuzz.gpa, .{ .entry_point = .{
1801	1818	.addr = addr,
1802	1819	.coverage_id = coverage_id.?,
1803	1820	} });
...	...	@@ -1900,6 +1917,22 @@ fn sendRunTestMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag, index:
1900	1917	try file.writeAll(full_msg);
1901	1918	}
1902	1919
	1920	fn sendRunFuzzTestMessage(
	1921	file: std.fs.File,
	1922	index: u32,
	1923	kind: std.Build.abi.fuzz.LimitKind,
	1924	amount_or_instance: u64,
	1925	) !void {
	1926	const header: std.zig.Client.Message.Header = .{
	1927	.tag = .start_fuzzing,
	1928	.bytes_len = 4 + 1 + 8,
	1929	};
	1930	const full_msg = std.mem.asBytes(&header) ++ std.mem.asBytes(&index) ++
	1931	std.mem.asBytes(&kind) ++ std.mem.asBytes(&amount_or_instance);
	1932
	1933	try file.writeAll(full_msg);
	1934	}
	1935
1903	1936	fn evalGeneric(run: Run, child: std.process.Child) !StdIoResult {
1904	1937	const b = run.step.owner;
1905	1938	const arena = b.allocator;

lib/std/Build/WebServer.zig+9-1

...	...	@@ -219,12 +219,20 @@ pub fn finishBuild(ws: *WebServer, opts: struct {
219	219	// Affects or affected by issues #5185, #22523, and #22464.
220	220	std.process.fatal("--fuzz not yet implemented on {d}-bit platforms", .{@bitSizeOf(usize)});
221	221	}
	222
222	223	assert(ws.fuzz == null);
223	224
224	225	ws.build_status.store(.fuzz_init, .monotonic);
225	226	ws.notifyUpdate();
226	227
227		ws.fuzz = Fuzz.init(ws) catch \|err\| std.process.fatal("failed to start fuzzer: {s}", .{@errorName(err)});
	228	ws.fuzz = Fuzz.init(
	229	ws.gpa,
	230	ws.thread_pool,
	231	ws.all_steps,
	232	ws.root_prog_node,
	233	ws.ttyconf,
	234	.{ .forever = .{ .ws = ws } },
	235	) catch \|err\| std.process.fatal("failed to start fuzzer: {s}", .{@errorName(err)});
228	236	ws.fuzz.?.start();
229	237	}
230	238

lib/std/Build/abi.zig+14-2

...	...	@@ -140,10 +140,10 @@ pub const Rebuild = extern struct {
140	140	pub const fuzz = struct {
141	141	pub const TestOne = *const fn (Slice) callconv(.c) void;
142	142	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;
144	144	pub extern fn fuzzer_init_test(test_one: TestOne, unit_test_name: Slice) void;
145	145	pub extern fn fuzzer_new_input(bytes: Slice) void;
146		pub extern fn fuzzer_main() void;
	146	pub extern fn fuzzer_main(limit_kind: LimitKind, amount: u64) void;
147	147
148	148	pub const Slice = extern struct {
149	149	ptr: [*]const u8,
...	...	@@ -158,6 +158,8 @@ pub const fuzz = struct {
158	158	}
159	159	};
160	160
	161	pub const LimitKind = enum(u8) { forever, iterations };
	162
161	163	/// libfuzzer uses this and its usize is the one that counts. To match the ABI,
162	164	/// make the ints be the size of the target used with libfuzzer.
163	165	///
...	...	@@ -251,6 +253,16 @@ pub const fuzz = struct {
251	253	return .{ .locs_len_raw = @bitCast(locs_len) };
252	254	}
253	255	};
	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	};
254	266	};
255	267
256	268	/// ABI bits specifically relating to the time report interface.

lib/std/zig/Client.zig+10-2

...	...	@@ -33,10 +33,18 @@ pub const Message = struct {
33	33	/// Ask the test runner to run a particular test.
34	34	/// The message body is a u32 test index.
35	35	run_test,
36		/// Ask the test runner to start fuzzing a particular test.
37		/// The message body is a u32 test index.
	36	/// Ask the test runner to start fuzzing a particular test forever or for a given amount of time/iterations.
	37	/// The message body is:
	38	/// - a u32 test index.
	39	/// - a u8 test limit kind (std.Build.api.fuzz.LimitKind)
	40	/// - a u64 value whose meaning depends on FuzzLimitKind (either a limit amount or an instance id)
38	41	start_fuzzing,
39	42
40	43	_,
41	44	};
	45
	46	comptime {
	47	const std = @import("std");
	48	std.debug.assert(@sizeOf(std.Build.abi.fuzz.LimitKind) == 1);
	49	}
42	50	};

lib/std/zig/Server.zig+26-3

...	...	@@ -42,9 +42,13 @@ pub const Message = struct {
42	42	/// The remaining bytes is the file path relative to that prefix.
43	43	/// The prefixes are hard-coded in Compilation.create (cwd, zig lib dir, local cache dir)
44	44	file_system_inputs,
45		/// Body is a u64le that indicates the file path within the cache used
46		/// to store coverage information. The integer is a hash of the PCs
47		/// stored within that file.
	45	/// Body is:
	46	/// - a u64le that indicates the file path within the cache used
	47	/// to store coverage information. The integer is a hash of the PCs
	48	/// stored within that file.
	49	/// - u64le of total runs accumulated
	50	/// - u64le of unique runs accumulated
	51	/// - u64le of coverage accumulated
48	52	coverage_id,
49	53	/// Body is a u64le that indicates the function pointer virtual memory
50	54	/// address of the fuzz unit test. This is used to provide a starting
...	...	@@ -141,9 +145,15 @@ pub fn receiveMessage(s: *Server) !InMessage.Header {
141	145	return s.in.takeStruct(InMessage.Header, .little);
142	146	}
143	147
	148	pub fn receiveBody_u8(s: *Server) !u8 {
	149	return s.in.takeInt(u8, .little);
	150	}
144	151	pub fn receiveBody_u32(s: *Server) !u32 {
145	152	return s.in.takeInt(u32, .little);
146	153	}
	154	pub fn receiveBody_u64(s: *Server) !u64 {
	155	return s.in.takeInt(u64, .little);
	156	}
147	157
148	158	pub fn serveStringMessage(s: *Server, tag: OutMessage.Tag, msg: []const u8) !void {
149	159	try s.serveMessageHeader(.{
...	...	@@ -160,6 +170,7 @@ pub fn serveMessageHeader(s: *const Server, header: OutMessage.Header) !void {
160	170	}
161	171
162	172	pub fn serveU64Message(s: *const Server, tag: OutMessage.Tag, int: u64) !void {
	173	assert(tag != .coverage_id);
163	174	try serveMessageHeader(s, .{
164	175	.tag = tag,
165	176	.bytes_len = @sizeOf(u64),
...	...	@@ -168,6 +179,18 @@ pub fn serveU64Message(s: *const Server, tag: OutMessage.Tag, int: u64) !void {
168	179	try s.out.flush();
169	180	}
170	181
	182	pub fn serveCoverageIdMessage(s: *const Server, id: u64, runs: u64, unique: u64, cov: u64) !void {
	183	try serveMessageHeader(s, .{
	184	.tag = .coverage_id,
	185	.bytes_len = @sizeOf(u64) + @sizeOf(u64) + @sizeOf(u64) + @sizeOf(u64),
	186	});
	187	try s.out.writeInt(u64, id, .little);
	188	try s.out.writeInt(u64, runs, .little);
	189	try s.out.writeInt(u64, unique, .little);
	190	try s.out.writeInt(u64, cov, .little);
	191	try s.out.flush();
	192	}
	193
171	194	pub fn serveEmitDigest(
172	195	s: *Server,
173	196	digest: *const [Cache.bin_digest_len]u8,

src/Compilation.zig+1-1

...	...	@@ -8120,7 +8120,7 @@ pub fn addLinkLib(comp: *Compilation, lib_name: []const u8) !void {
8120	8120	/// compiler-rt, libcxx, libc, libunwind, etc.
8121	8121	pub fn compilerRtOptMode(comp: Compilation) std.builtin.OptimizeMode {
8122	8122	if (comp.debug_compiler_runtime_libs) {
8123		return comp.root_mod.optimize_mode;
	8123	return .Debug;
8124	8124	}
8125	8125	const target = &comp.root_mod.resolved_target.result;
8126	8126	switch (comp.root_mod.optimize_mode) {

test/standalone/libfuzzer/main.zig+1-1

...	...	@@ -24,7 +24,7 @@ pub fn main() !void {
24	24	abi.fuzzer_new_input(.fromSlice(""));
25	25	abi.fuzzer_new_input(.fromSlice("hello"));
26	26
27		const pc_digest = abi.fuzzer_coverage_id();
	27	const pc_digest = abi.fuzzer_coverage().id;
28	28	const coverage_file_path = "v/" ++ std.fmt.hex(pc_digest);
29	29	const coverage_file = try cache_dir.openFile(coverage_file_path, .{});
30	30	defer coverage_file.close();

author	Andrew Kelley <andrew@ziglang.org> 2025-09-26 05:28:46-07:00
committer	GitHub <noreply@github.com> 2025-09-26 05:28:46-07:00
log	e0dc2e4e3ffe72e5e637e30bdf1d2c59b56f3cb6
tree	23cafd6ae8e80026c2f257d291b91bae932e5730
parent	3b365a1f9b277dd2cf7f7dac51e71647e164ff3c
parent	52a13f6a7fb0933c065348128ee3e9aecd64255b
signature	Signed by PGP key B5690EEEBB952194

Merge pull request #25342 from ziglang/fuzz-limit