diff --git a/lib/fuzzer/web/main.zig b/lib/build-web/fuzz.zig
similarity index 52%
rename from lib/fuzzer/web/main.zig
rename to lib/build-web/fuzz.zig
index 5b16b0532ccf..a05f9d2e649a 100644
--- a/lib/fuzzer/web/main.zig
+++ b/lib/build-web/fuzz.zig
@@ -1,229 +1,26 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const abi = std.Build.Fuzz.abi;
-const gpa = std.heap.wasm_allocator;
-const log = std.log;
-const Coverage = std.debug.Coverage;
-const Allocator = std.mem.Allocator;
-
-const Walk = @import("Walk");
-const Decl = Walk.Decl;
-const html_render = @import("html_render");
-
-/// Nanoseconds.
-var server_base_timestamp: i64 = 0;
-/// Milliseconds.
-var client_base_timestamp: i64 = 0;
-/// Relative to `server_base_timestamp`.
+// Server timestamp.
var start_fuzzing_timestamp: i64 = undefined;
const js = struct {
- extern "js" fn log(ptr: [*]const u8, len: usize) void;
- extern "js" fn panic(ptr: [*]const u8, len: usize) noreturn;
- extern "js" fn timestamp() i64;
- extern "js" fn emitSourceIndexChange() void;
- extern "js" fn emitCoverageUpdate() void;
- extern "js" fn emitEntryPointsUpdate() void;
-};
+ extern "fuzz" fn requestSources() void;
+ extern "fuzz" fn ready() void;
-pub const std_options: std.Options = .{
- .logFn = logFn,
+ extern "fuzz" fn updateStats(html_ptr: [*]const u8, html_len: usize) void;
+ extern "fuzz" fn updateEntryPoints(html_ptr: [*]const u8, html_len: usize) void;
+ extern "fuzz" fn updateSource(html_ptr: [*]const u8, html_len: usize) void;
+ extern "fuzz" fn updateCoverage(covered_ptr: [*]const SourceLocationIndex, covered_len: u32) void;
};
-pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noreturn {
- _ = st;
- _ = addr;
- log.err("panic: {s}", .{msg});
- @trap();
-}
-
-fn logFn(
- comptime message_level: log.Level,
- comptime scope: @TypeOf(.enum_literal),
- comptime format: []const u8,
- args: anytype,
-) void {
- const level_txt = comptime message_level.asText();
- const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
- var buf: [500]u8 = undefined;
- const line = std.fmt.bufPrint(&buf, level_txt ++ prefix2 ++ format, args) catch l: {
- buf[buf.len - 3 ..][0..3].* = "...".*;
- break :l &buf;
- };
- js.log(line.ptr, line.len);
-}
-
-export fn alloc(n: usize) [*]u8 {
- const slice = gpa.alloc(u8, n) catch @panic("OOM");
- return slice.ptr;
-}
-
-var message_buffer: std.ArrayListAlignedUnmanaged(u8, .of(u64)) = .empty;
-
-/// Resizes the message buffer to be the correct length; returns the pointer to
-/// the query string.
-export fn message_begin(len: usize) [*]u8 {
- message_buffer.resize(gpa, len) catch @panic("OOM");
- return message_buffer.items.ptr;
-}
-
-export fn message_end() void {
- const msg_bytes = message_buffer.items;
-
- const tag: abi.ToClientTag = @enumFromInt(msg_bytes[0]);
- switch (tag) {
- .current_time => return currentTimeMessage(msg_bytes),
- .source_index => return sourceIndexMessage(msg_bytes) catch @panic("OOM"),
- .coverage_update => return coverageUpdateMessage(msg_bytes) catch @panic("OOM"),
- .entry_points => return entryPointsMessage(msg_bytes) catch @panic("OOM"),
- _ => unreachable,
- }
-}
-
-export fn unpack(tar_ptr: [*]u8, tar_len: usize) void {
- const tar_bytes = tar_ptr[0..tar_len];
- log.debug("received {d} bytes of tar file", .{tar_bytes.len});
-
- unpackInner(tar_bytes) catch |err| {
- fatal("unable to unpack tar: {s}", .{@errorName(err)});
- };
-}
-
-/// Set by `set_input_string`.
-var input_string: std.ArrayListUnmanaged(u8) = .empty;
-var string_result: std.ArrayListUnmanaged(u8) = .empty;
-
-export fn set_input_string(len: usize) [*]u8 {
- input_string.resize(gpa, len) catch @panic("OOM");
- return input_string.items.ptr;
-}
-
-/// Looks up the root struct decl corresponding to a file by path.
-/// Uses `input_string`.
-export fn find_file_root() Decl.Index {
- const file: Walk.File.Index = @enumFromInt(Walk.files.getIndex(input_string.items) orelse return .none);
- return file.findRootDecl();
-}
-
-export fn decl_source_html(decl_index: Decl.Index) String {
- const decl = decl_index.get();
-
- string_result.clearRetainingCapacity();
- html_render.fileSourceHtml(decl.file, &string_result, decl.ast_node, .{}) catch |err| {
- fatal("unable to render source: {s}", .{@errorName(err)});
- };
- return String.init(string_result.items);
-}
-
-export fn totalSourceLocations() usize {
- return coverage_source_locations.items.len;
-}
-
-export fn coveredSourceLocations() usize {
- const covered_bits = recent_coverage_update.items[@sizeOf(abi.CoverageUpdateHeader)..];
- var count: usize = 0;
- for (covered_bits) |byte| count += @popCount(byte);
- return count;
-}
-
-fn getCoverageUpdateHeader() *abi.CoverageUpdateHeader {
- return @alignCast(@ptrCast(recent_coverage_update.items[0..@sizeOf(abi.CoverageUpdateHeader)]));
-}
-
-export fn totalRuns() u64 {
- const header = getCoverageUpdateHeader();
- return header.n_runs;
-}
-
-export fn uniqueRuns() u64 {
- const header = getCoverageUpdateHeader();
- return header.unique_runs;
-}
-
-export fn totalRunsPerSecond() f64 {
- @setFloatMode(.optimized);
- const header = getCoverageUpdateHeader();
- const ns_elapsed: f64 = @floatFromInt(nsSince(start_fuzzing_timestamp));
- const n_runs: f64 = @floatFromInt(header.n_runs);
- return n_runs / (ns_elapsed / std.time.ns_per_s);
-}
-
-const String = Slice(u8);
-
-fn Slice(T: type) type {
- return packed struct(u64) {
- ptr: u32,
- len: u32,
-
- fn init(s: []const T) @This() {
- return .{
- .ptr = @intFromPtr(s.ptr),
- .len = s.len,
- };
- }
- };
-}
-
-fn unpackInner(tar_bytes: []u8) !void {
- var fbs = std.io.fixedBufferStream(tar_bytes);
- var file_name_buffer: [1024]u8 = undefined;
- var link_name_buffer: [1024]u8 = undefined;
- var it = std.tar.iterator(fbs.reader(), .{
- .file_name_buffer = &file_name_buffer,
- .link_name_buffer = &link_name_buffer,
- });
- while (try it.next()) |tar_file| {
- switch (tar_file.kind) {
- .file => {
- if (tar_file.size == 0 and tar_file.name.len == 0) break;
- if (std.mem.endsWith(u8, tar_file.name, ".zig")) {
- log.debug("found file: '{s}'", .{tar_file.name});
- const file_name = try gpa.dupe(u8, tar_file.name);
- if (std.mem.indexOfScalar(u8, file_name, '/')) |pkg_name_end| {
- const pkg_name = file_name[0..pkg_name_end];
- const gop = try Walk.modules.getOrPut(gpa, pkg_name);
- const file: Walk.File.Index = @enumFromInt(Walk.files.entries.len);
- if (!gop.found_existing or
- std.mem.eql(u8, file_name[pkg_name_end..], "/root.zig") or
- std.mem.eql(u8, file_name[pkg_name_end + 1 .. file_name.len - ".zig".len], pkg_name))
- {
- gop.value_ptr.* = file;
- }
- const file_bytes = tar_bytes[fbs.pos..][0..@intCast(tar_file.size)];
- assert(file == try Walk.add_file(file_name, file_bytes));
- }
- } else {
- log.warn("skipping: '{s}' - the tar creation should have done that", .{tar_file.name});
- }
- },
- else => continue,
- }
- }
-}
-
-fn fatal(comptime format: []const u8, args: anytype) noreturn {
- var buf: [500]u8 = undefined;
- const line = std.fmt.bufPrint(&buf, format, args) catch l: {
- buf[buf.len - 3 ..][0..3].* = "...".*;
- break :l &buf;
- };
- js.panic(line.ptr, line.len);
-}
-
-fn currentTimeMessage(msg_bytes: []u8) void {
- client_base_timestamp = js.timestamp();
- server_base_timestamp = @bitCast(msg_bytes[1..][0..8].*);
-}
+pub fn sourceIndexMessage(msg_bytes: []u8) error{OutOfMemory}!void {
+ Walk.files.clearRetainingCapacity();
+ Walk.decls.clearRetainingCapacity();
+ Walk.modules.clearRetainingCapacity();
+ recent_coverage_update.clearRetainingCapacity();
+ selected_source_location = null;
-/// Nanoseconds passed since a server timestamp.
-fn nsSince(server_timestamp: i64) i64 {
- const ms_passed = js.timestamp() - client_base_timestamp;
- const ns_passed = server_base_timestamp - server_timestamp;
- return ns_passed + ms_passed * std.time.ns_per_ms;
-}
+ js.requestSources();
-fn sourceIndexMessage(msg_bytes: []u8) error{OutOfMemory}!void {
- const Header = abi.SourceIndexHeader;
+ const Header = abi.fuzz.SourceIndexHeader;
const header: Header = @bitCast(msg_bytes[0..@sizeOf(Header)].*);
const directories_start = @sizeOf(Header);
@@ -239,27 +36,55 @@ fn sourceIndexMessage(msg_bytes: []u8) error{OutOfMemory}!void {
const source_locations: []const Coverage.SourceLocation = @alignCast(std.mem.bytesAsSlice(Coverage.SourceLocation, msg_bytes[source_locations_start..source_locations_end]));
start_fuzzing_timestamp = header.start_timestamp;
- try updateCoverage(directories, files, source_locations, string_bytes);
- js.emitSourceIndexChange();
+ try updateCoverageSources(directories, files, source_locations, string_bytes);
+ js.ready();
}
-fn coverageUpdateMessage(msg_bytes: []u8) error{OutOfMemory}!void {
+var coverage = Coverage.init;
+/// Index of type `SourceLocationIndex`.
+var coverage_source_locations: std.ArrayListUnmanaged(Coverage.SourceLocation) = .empty;
+/// Contains the most recent coverage update message, unmodified.
+var recent_coverage_update: std.ArrayListAlignedUnmanaged(u8, .of(u64)) = .empty;
+
+fn updateCoverageSources(
+ directories: []const Coverage.String,
+ files: []const Coverage.File,
+ source_locations: []const Coverage.SourceLocation,
+ string_bytes: []const u8,
+) !void {
+ coverage.directories.clearRetainingCapacity();
+ coverage.files.clearRetainingCapacity();
+ coverage.string_bytes.clearRetainingCapacity();
+ coverage_source_locations.clearRetainingCapacity();
+
+ try coverage_source_locations.appendSlice(gpa, source_locations);
+ try coverage.string_bytes.appendSlice(gpa, string_bytes);
+
+ try coverage.files.entries.resize(gpa, files.len);
+ @memcpy(coverage.files.entries.items(.key), files);
+ try coverage.files.reIndexContext(gpa, .{ .string_bytes = coverage.string_bytes.items });
+
+ try coverage.directories.entries.resize(gpa, directories.len);
+ @memcpy(coverage.directories.entries.items(.key), directories);
+ try coverage.directories.reIndexContext(gpa, .{ .string_bytes = coverage.string_bytes.items });
+}
+
+pub fn coverageUpdateMessage(msg_bytes: []u8) error{OutOfMemory}!void {
recent_coverage_update.clearRetainingCapacity();
recent_coverage_update.appendSlice(gpa, msg_bytes) catch @panic("OOM");
- js.emitCoverageUpdate();
+ try updateStats();
+ try updateCoverage();
}
-var entry_points: std.ArrayListUnmanaged(u32) = .empty;
-
-fn entryPointsMessage(msg_bytes: []u8) error{OutOfMemory}!void {
- const header: abi.EntryPointHeader = @bitCast(msg_bytes[0..@sizeOf(abi.EntryPointHeader)].*);
- entry_points.resize(gpa, header.flags.locs_len) catch @panic("OOM");
- @memcpy(entry_points.items, std.mem.bytesAsSlice(u32, msg_bytes[@sizeOf(abi.EntryPointHeader)..]));
- js.emitEntryPointsUpdate();
-}
+var entry_points: std.ArrayListUnmanaged(SourceLocationIndex) = .empty;
-export fn entryPoints() Slice(u32) {
- return Slice(u32).init(entry_points.items);
+pub fn entryPointsMessage(msg_bytes: []u8) error{OutOfMemory}!void {
+ const header: abi.fuzz.EntryPointHeader = @bitCast(msg_bytes[0..@sizeOf(abi.fuzz.EntryPointHeader)].*);
+ const slis: []align(1) const SourceLocationIndex = @ptrCast(msg_bytes[@sizeOf(abi.fuzz.EntryPointHeader)..]);
+ assert(slis.len == header.locsLen());
+ try entry_points.resize(gpa, slis.len);
+ @memcpy(entry_points.items, slis);
+ try updateEntryPoints();
}
/// Index into `coverage_source_locations`.
@@ -277,11 +102,18 @@ const SourceLocationIndex = enum(u32) {
fn sourceLocationLinkHtml(
sli: SourceLocationIndex,
out: *std.ArrayListUnmanaged(u8),
+ focused: bool,
) Allocator.Error!void {
const sl = sli.ptr();
- try out.writer(gpa).print("", .{@intFromEnum(sli)});
+ try out.writer(gpa).print("", .{
+ @as([]const u8, if (focused) " class=\"status-running\"" else ""),
+ });
try sli.appendPath(out);
- try out.writer(gpa).print(":{d}:{d} ", .{ sl.line, sl.column });
+ try out.writer(gpa).print(":{d}:{d} View ", .{
+ sl.line,
+ sl.column,
+ @intFromEnum(sli),
+ });
}
fn appendPath(sli: SourceLocationIndex, out: *std.ArrayListUnmanaged(u8)) Allocator.Error!void {
@@ -372,84 +204,174 @@ fn computeSourceAnnotations(
}
}
-var coverage = Coverage.init;
-/// Index of type `SourceLocationIndex`.
-var coverage_source_locations: std.ArrayListUnmanaged(Coverage.SourceLocation) = .empty;
-/// Contains the most recent coverage update message, unmodified.
-var recent_coverage_update: std.ArrayListAlignedUnmanaged(u8, .of(u64)) = .empty;
+export fn fuzzUnpackSources(tar_ptr: [*]u8, tar_len: usize) void {
+ const tar_bytes = tar_ptr[0..tar_len];
+ log.debug("received {d} bytes of sources.tar", .{tar_bytes.len});
-fn updateCoverage(
- directories: []const Coverage.String,
- files: []const Coverage.File,
- source_locations: []const Coverage.SourceLocation,
- string_bytes: []const u8,
-) !void {
- coverage.directories.clearRetainingCapacity();
- coverage.files.clearRetainingCapacity();
- coverage.string_bytes.clearRetainingCapacity();
- coverage_source_locations.clearRetainingCapacity();
+ unpackSourcesInner(tar_bytes) catch |err| {
+ fatal("unable to unpack sources.tar: {s}", .{@errorName(err)});
+ };
+}
- try coverage_source_locations.appendSlice(gpa, source_locations);
- try coverage.string_bytes.appendSlice(gpa, string_bytes);
+fn unpackSourcesInner(tar_bytes: []u8) !void {
+ var tar_reader: std.Io.Reader = .fixed(tar_bytes);
+ var file_name_buffer: [1024]u8 = undefined;
+ var link_name_buffer: [1024]u8 = undefined;
+ var it: std.tar.Iterator = .init(&tar_reader, .{
+ .file_name_buffer = &file_name_buffer,
+ .link_name_buffer = &link_name_buffer,
+ });
+ while (try it.next()) |tar_file| {
+ switch (tar_file.kind) {
+ .file => {
+ if (tar_file.size == 0 and tar_file.name.len == 0) break;
+ if (std.mem.endsWith(u8, tar_file.name, ".zig")) {
+ log.debug("found file: '{s}'", .{tar_file.name});
+ const file_name = try gpa.dupe(u8, tar_file.name);
+ if (std.mem.indexOfScalar(u8, file_name, '/')) |pkg_name_end| {
+ const pkg_name = file_name[0..pkg_name_end];
+ const gop = try Walk.modules.getOrPut(gpa, pkg_name);
+ const file: Walk.File.Index = @enumFromInt(Walk.files.entries.len);
+ if (!gop.found_existing or
+ std.mem.eql(u8, file_name[pkg_name_end..], "/root.zig") or
+ std.mem.eql(u8, file_name[pkg_name_end + 1 .. file_name.len - ".zig".len], pkg_name))
+ {
+ gop.value_ptr.* = file;
+ }
+ const file_bytes = tar_reader.take(@intCast(tar_file.size)) catch unreachable;
+ it.unread_file_bytes = 0; // we have read the whole thing
+ assert(file == try Walk.add_file(file_name, file_bytes));
+ }
+ } else {
+ log.warn("skipping: '{s}' - the tar creation should have done that", .{tar_file.name});
+ }
+ },
+ else => continue,
+ }
+ }
+}
- try coverage.files.entries.resize(gpa, files.len);
- @memcpy(coverage.files.entries.items(.key), files);
- try coverage.files.reIndexContext(gpa, .{ .string_bytes = coverage.string_bytes.items });
+fn updateStats() error{OutOfMemory}!void {
+ @setFloatMode(.optimized);
- try coverage.directories.entries.resize(gpa, directories.len);
- @memcpy(coverage.directories.entries.items(.key), directories);
- try coverage.directories.reIndexContext(gpa, .{ .string_bytes = coverage.string_bytes.items });
-}
+ if (recent_coverage_update.items.len == 0) return;
-export fn sourceLocationLinkHtml(index: SourceLocationIndex) String {
- string_result.clearRetainingCapacity();
- index.sourceLocationLinkHtml(&string_result) catch @panic("OOM");
- return String.init(string_result.items);
-}
+ const hdr: *abi.fuzz.CoverageUpdateHeader = @alignCast(@ptrCast(
+ recent_coverage_update.items[0..@sizeOf(abi.fuzz.CoverageUpdateHeader)],
+ ));
-/// Returns empty string if coverage metadata is not available for this source location.
-export fn sourceLocationPath(sli: SourceLocationIndex) String {
- string_result.clearRetainingCapacity();
- if (sli.haveCoverage()) sli.appendPath(&string_result) catch @panic("OOM");
- return String.init(string_result.items);
-}
+ const covered_src_locs: usize = n: {
+ var n: usize = 0;
+ const covered_bits = recent_coverage_update.items[@sizeOf(abi.fuzz.CoverageUpdateHeader)..];
+ for (covered_bits) |byte| n += @popCount(byte);
+ break :n n;
+ };
+ const total_src_locs = coverage_source_locations.items.len;
-export fn sourceLocationFileHtml(sli: SourceLocationIndex) String {
- string_result.clearRetainingCapacity();
- sli.fileHtml(&string_result) catch |err| switch (err) {
- error.OutOfMemory => @panic("OOM"),
- error.SourceUnavailable => {},
+ const avg_speed: f64 = speed: {
+ const ns_elapsed: f64 = @floatFromInt(nsSince(start_fuzzing_timestamp));
+ const n_runs: f64 = @floatFromInt(hdr.n_runs);
+ break :speed n_runs / (ns_elapsed / std.time.ns_per_s);
};
- return String.init(string_result.items);
+
+ const html = try std.fmt.allocPrint(gpa,
+ \\{d}
+ \\{d} ({d:.1}%)
+ \\{d} / {d} ({d:.1}%)
+ \\{d:.0}
+ , .{
+ hdr.n_runs,
+ hdr.unique_runs,
+ @as(f64, @floatFromInt(hdr.unique_runs)) / @as(f64, @floatFromInt(hdr.n_runs)),
+ covered_src_locs,
+ total_src_locs,
+ @as(f64, @floatFromInt(covered_src_locs)) / @as(f64, @floatFromInt(total_src_locs)),
+ avg_speed,
+ });
+ defer gpa.free(html);
+
+ js.updateStats(html.ptr, html.len);
}
-export fn sourceLocationFileCoveredList(sli_file: SourceLocationIndex) Slice(SourceLocationIndex) {
- const global = struct {
- var result: std.ArrayListUnmanaged(SourceLocationIndex) = .empty;
- fn add(i: u32, want_file: Coverage.File.Index) void {
- const src_loc_index: SourceLocationIndex = @enumFromInt(i);
- if (src_loc_index.ptr().file == want_file) result.appendAssumeCapacity(src_loc_index);
- }
- };
- const want_file = sli_file.ptr().file;
- global.result.clearRetainingCapacity();
+fn updateEntryPoints() error{OutOfMemory}!void {
+ var html: std.ArrayListUnmanaged(u8) = .empty;
+ defer html.deinit(gpa);
+ for (entry_points.items) |sli| {
+ try html.appendSlice(gpa, "");
+ try sli.sourceLocationLinkHtml(&html, selected_source_location == sli);
+ try html.appendSlice(gpa, " \n");
+ }
+ js.updateEntryPoints(html.items.ptr, html.items.len);
+}
+
+fn updateCoverage() error{OutOfMemory}!void {
+ if (recent_coverage_update.items.len == 0) return;
+ const want_file = (selected_source_location orelse return).ptr().file;
+
+ var covered: std.ArrayListUnmanaged(SourceLocationIndex) = .empty;
+ defer covered.deinit(gpa);
// This code assumes 64-bit elements, which is incorrect if the executable
// being fuzzed is not a 64-bit CPU. It also assumes little-endian which
// can also be incorrect.
- comptime assert(abi.CoverageUpdateHeader.trailing[0] == .pc_bits_usize);
+ comptime assert(abi.fuzz.CoverageUpdateHeader.trailing[0] == .pc_bits_usize);
const n_bitset_elems = (coverage_source_locations.items.len + @bitSizeOf(u64) - 1) / @bitSizeOf(u64);
const covered_bits = std.mem.bytesAsSlice(
u64,
- recent_coverage_update.items[@sizeOf(abi.CoverageUpdateHeader)..][0 .. n_bitset_elems * @sizeOf(u64)],
+ recent_coverage_update.items[@sizeOf(abi.fuzz.CoverageUpdateHeader)..][0 .. n_bitset_elems * @sizeOf(u64)],
);
- var sli: u32 = 0;
+ var sli: SourceLocationIndex = @enumFromInt(0);
for (covered_bits) |elem| {
- global.result.ensureUnusedCapacity(gpa, 64) catch @panic("OOM");
+ try covered.ensureUnusedCapacity(gpa, 64);
for (0..@bitSizeOf(u64)) |i| {
- if ((elem & (@as(u64, 1) << @intCast(i))) != 0) global.add(sli, want_file);
- sli += 1;
+ if ((elem & (@as(u64, 1) << @intCast(i))) != 0) {
+ if (sli.ptr().file == want_file) {
+ covered.appendAssumeCapacity(sli);
+ }
+ }
+ sli = @enumFromInt(@intFromEnum(sli) + 1);
}
}
- return Slice(SourceLocationIndex).init(global.result.items);
+
+ js.updateCoverage(covered.items.ptr, covered.items.len);
}
+
+fn updateSource() error{OutOfMemory}!void {
+ if (recent_coverage_update.items.len == 0) return;
+ const file_sli = selected_source_location.?;
+ var html: std.ArrayListUnmanaged(u8) = .empty;
+ defer html.deinit(gpa);
+ file_sli.fileHtml(&html) catch |err| switch (err) {
+ error.OutOfMemory => |e| return e,
+ error.SourceUnavailable => {},
+ };
+ js.updateSource(html.items.ptr, html.items.len);
+}
+
+var selected_source_location: ?SourceLocationIndex = null;
+
+/// This function is not used directly by `main.js`, but a reference to it is
+/// emitted by `SourceLocationIndex.sourceLocationLinkHtml`.
+export fn fuzzSelectSli(sli: SourceLocationIndex) void {
+ if (!sli.haveCoverage()) return;
+ selected_source_location = sli;
+ updateEntryPoints() catch @panic("out of memory"); // highlights the selected one green
+ updateSource() catch @panic("out of memory");
+ updateCoverage() catch @panic("out of memory");
+}
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const Coverage = std.debug.Coverage;
+const abi = std.Build.abi;
+const assert = std.debug.assert;
+const gpa = std.heap.wasm_allocator;
+
+const Walk = @import("Walk");
+const html_render = @import("html_render");
+
+const nsSince = @import("main.zig").nsSince;
+const Slice = @import("main.zig").Slice;
+const fatal = @import("main.zig").fatal;
+const log = std.log;
+const String = Slice(u8);
diff --git a/lib/build-web/index.html b/lib/build-web/index.html
new file mode 100644
index 000000000000..117ae14c209c
--- /dev/null
+++ b/lib/build-web/index.html
@@ -0,0 +1,202 @@
+
+
+Zig Build System
+
+
+
+
+ Files Discovered:
+
+
+
+ Pipeline Component
+ CPU Time
+ Sum across all threads of the time spent in this pipeline component
+
+ Real Time
+ Wall-clock time elapsed between the start and end of this compilation phase
+
+ Compilation Phase
+
+
+
+
+ Parsing
+ tokenize converts a file of Zig source code into a sequence of tokens, which are then processed by Parse into an Abstract Syntax Tree (AST).
+ File Lower
+ Tokenization, parsing, and lowering of Zig source files to a high-level IR.@import calls is processed. Individual source files are processed serially, but different files are processed in parallel by a thread pool.
+
+
+
+ AST Lowering
+ AstGen converts a file's AST into a high-level SSA IR named Zig Intermediate Representation (ZIR). The resulting ZIR code is cached on disk to avoid, for instance, re-lowering all source files in the Zig standard library each time the compiler is invoked.
+
+
+ Semantic Analysis
+ Sema interprets ZIR to perform type checking, compile-time code execution, and type resolution, collectively termed "semantic analysis". When a runtime function body is analyzed, it emits Analyzed Intermediate Representation (AIR) code to be sent to the next pipeline component. Semantic analysis is currently entirely single-threaded.
+ Declaration Lower
+ Semantic analysis, code generation, and linking, at the granularity of individual declarations (as opposed to whole source files).
+
+
+
+ Code Generation
+ CodeGen converts AIR from Sema into machine instructions in the form of Machine Intermediate Representation (MIR). This work is usually highly parallel, since in most cases, arbitrarily many functions can be run through CodeGen simultaneously.
+
+
+ Linking
+ link converts MIR from CodeGen, as well as global constants and variables from Sema, and places them in the output binary. MIR is converted to a finished sequence of real instruction bytes.
+
+
+ LLVM Emit
+ Only applicable when using the LLVM backend.
+
+
+ Linker Flush
+ Finalizing the emitted binary, and ensuring it is fully written to disk.
+
+
+
+
+
+ Files
+
+
+
+ File
+ Semantic Analysis
+ Code Generation
+ Linking
+
+
+
+
+
+
+ Declarations
+
+
+
+ File
+ Declaration
+ Analysis Count
+ The number of times the compiler analyzed some part of this declaration. If this is a function, inline and comptime calls to it are not included here. Typically, this value is approximately equal to the number of instances of a generic declaration.
+
+ Semantic Analysis
+ Code Generation
+ Linking
+
+
+
+
+
+
+ LLVM Pass Timings
+
+
+
+
+
+
+
+ Total Runs:
+ Unique Runs:
+ Speed:
+ Coverage:
+
+
+
+
+
+
+
+
+Loading JavaScript...
+
+If you are using Firefox and zig build --listen is definitely running, you may be experiencing an unreasonably aggressive exponential
+backoff for WebSocket connection attempts, which is enabled by default and can block connection attempts for up to a minute. To disable this limit,
+open about:config and set the network.websocket.delay-failed-reconnects option to false.
+
+
+ Zig Build System
+
+
+ Rebuild
+
+
+
+ Help
+ This is the Zig Build System web interface. It allows live interaction with the build system.
+ The following zig build flags can expose extra features of this interface:
+
+ --time-report: collect and show statistics about the time taken to evaluate a build graph--fuzz: enable the fuzzer for any Zig test binaries in the build graph (experimental)
+
+
+
+
+
diff --git a/lib/build-web/main.js b/lib/build-web/main.js
new file mode 100644
index 000000000000..481c33f024ba
--- /dev/null
+++ b/lib/build-web/main.js
@@ -0,0 +1,346 @@
+const domConnectionStatus = document.getElementById("connectionStatus");
+const domFirefoxWebSocketBullshitExplainer = document.getElementById("firefoxWebSocketBullshitExplainer");
+
+const domMain = document.getElementsByTagName("main")[0];
+const domSummary = {
+ stepCount: document.getElementById("summaryStepCount"),
+ status: document.getElementById("summaryStatus"),
+};
+const domButtonRebuild = document.getElementById("buttonRebuild");
+const domStepList = document.getElementById("stepList");
+let domSteps = [];
+
+let wasm_promise = fetch("main.wasm");
+let wasm_exports = null;
+
+const text_decoder = new TextDecoder();
+const text_encoder = new TextEncoder();
+
+domButtonRebuild.addEventListener("click", () => wasm_exports.rebuild());
+
+setConnectionStatus("Loading WebAssembly...", false);
+WebAssembly.instantiateStreaming(wasm_promise, {
+ core: {
+ log: function(ptr, len) {
+ const msg = decodeString(ptr, len);
+ console.log(msg);
+ },
+ panic: function (ptr, len) {
+ const msg = decodeString(ptr, len);
+ throw new Error("panic: " + msg);
+ },
+ timestamp: function () {
+ return BigInt(new Date());
+ },
+ hello: hello,
+ updateBuildStatus: updateBuildStatus,
+ updateStepStatus: updateStepStatus,
+ sendWsMessage: (ptr, len) => ws.send(new Uint8Array(wasm_exports.memory.buffer, ptr, len)),
+ },
+ fuzz: {
+ requestSources: fuzzRequestSources,
+ ready: fuzzReady,
+ updateStats: fuzzUpdateStats,
+ updateEntryPoints: fuzzUpdateEntryPoints,
+ updateSource: fuzzUpdateSource,
+ updateCoverage: fuzzUpdateCoverage,
+ },
+ time_report: {
+ updateCompile: timeReportUpdateCompile,
+ updateGeneric: timeReportUpdateGeneric,
+ },
+}).then(function(obj) {
+ setConnectionStatus("Connecting to WebSocket...", true);
+ connectWebSocket();
+
+ wasm_exports = obj.instance.exports;
+ window.wasm = obj; // for debugging
+});
+
+function connectWebSocket() {
+ const host = document.location.host;
+ const pathname = document.location.pathname;
+ const isHttps = document.location.protocol === 'https:';
+ const match = host.match(/^(.+):(\d+)$/);
+ const defaultPort = isHttps ? 443 : 80;
+ const port = match ? parseInt(match[2], 10) : defaultPort;
+ const hostName = match ? match[1] : host;
+ const wsProto = isHttps ? "wss:" : "ws:";
+ const wsUrl = wsProto + '//' + hostName + ':' + port + pathname;
+ ws = new WebSocket(wsUrl);
+ ws.binaryType = "arraybuffer";
+ ws.addEventListener('message', onWebSocketMessage, false);
+ ws.addEventListener('error', onWebSocketClose, false);
+ ws.addEventListener('close', onWebSocketClose, false);
+ ws.addEventListener('open', onWebSocketOpen, false);
+}
+function onWebSocketOpen() {
+ setConnectionStatus("Waiting for data...", false);
+}
+function onWebSocketMessage(ev) {
+ const jsArray = new Uint8Array(ev.data);
+ const ptr = wasm_exports.message_begin(jsArray.length);
+ const wasmArray = new Uint8Array(wasm_exports.memory.buffer, ptr, jsArray.length);
+ wasmArray.set(jsArray);
+ wasm_exports.message_end();
+}
+function onWebSocketClose() {
+ setConnectionStatus("WebSocket connection closed. Re-connecting...", true);
+ ws.removeEventListener('message', onWebSocketMessage, false);
+ ws.removeEventListener('error', onWebSocketClose, false);
+ ws.removeEventListener('close', onWebSocketClose, false);
+ ws.removeEventListener('open', onWebSocketOpen, false);
+ ws = null;
+ setTimeout(connectWebSocket, 1000);
+}
+
+function setConnectionStatus(msg, is_websocket_connect) {
+ domConnectionStatus.textContent = msg;
+ if (msg.length > 0) {
+ domConnectionStatus.classList.remove("hidden");
+ domMain.classList.add("hidden");
+ } else {
+ domConnectionStatus.classList.add("hidden");
+ domMain.classList.remove("hidden");
+ }
+ if (is_websocket_connect) {
+ domFirefoxWebSocketBullshitExplainer.classList.remove("hidden");
+ } else {
+ domFirefoxWebSocketBullshitExplainer.classList.add("hidden");
+ }
+}
+
+function hello(
+ steps_len,
+ build_status,
+ time_report,
+) {
+ domSummary.stepCount.textContent = steps_len;
+ updateBuildStatus(build_status);
+ setConnectionStatus("", false);
+
+ {
+ let entries = [];
+ for (let i = 0; i < steps_len; i += 1) {
+ const step_name = unwrapString(wasm_exports.stepName(i));
+ const code = document.createElement("code");
+ code.textContent = step_name;
+ const li = document.createElement("li");
+ li.appendChild(code);
+ entries.push(li);
+ }
+ domStepList.replaceChildren(...entries);
+ for (let i = 0; i < steps_len; i += 1) {
+ updateStepStatus(i);
+ }
+ }
+
+ if (time_report) timeReportReset(steps_len);
+ fuzzReset();
+}
+
+function updateBuildStatus(s) {
+ let text;
+ let active = false;
+ let reset_time_reports = false;
+ if (s == 0) {
+ text = "Idle";
+ } else if (s == 1) {
+ text = "Watching for changes...";
+ } else if (s == 2) {
+ text = "Running...";
+ active = true;
+ reset_time_reports = true;
+ } else if (s == 3) {
+ text = "Starting fuzzer...";
+ active = true;
+ } else {
+ console.log(`bad build status: ${s}`);
+ }
+ domSummary.status.textContent = text;
+ if (active) {
+ domSummary.status.classList.add("status-running");
+ domSummary.status.classList.remove("status-idle");
+ domButtonRebuild.disabled = true;
+ } else {
+ domSummary.status.classList.remove("status-running");
+ domSummary.status.classList.add("status-idle");
+ domButtonRebuild.disabled = false;
+ }
+ if (reset_time_reports) {
+ // Grey out and collapse all the time reports
+ for (const time_report_host of domTimeReportList.children) {
+ const details = time_report_host.shadowRoot.querySelector(":host > details");
+ details.classList.add("pending");
+ details.open = false;
+ }
+ }
+}
+function updateStepStatus(step_idx) {
+ const li = domStepList.children[step_idx];
+ const step_status = wasm_exports.stepStatus(step_idx);
+ li.classList.remove("step-wip", "step-success", "step-failure");
+ if (step_status == 0) {
+ // pending
+ } else if (step_status == 1) {
+ li.classList.add("step-wip");
+ } else if (step_status == 2) {
+ li.classList.add("step-success");
+ } else if (step_status == 3) {
+ li.classList.add("step-failure");
+ } else {
+ console.log(`bad step status: ${step_status}`);
+ }
+}
+
+function decodeString(ptr, len) {
+ if (len === 0) return "";
+ return text_decoder.decode(new Uint8Array(wasm_exports.memory.buffer, ptr, len));
+}
+function getU32Array(ptr, len) {
+ if (len === 0) return new Uint32Array();
+ return new Uint32Array(wasm_exports.memory.buffer, ptr, len);
+}
+function unwrapString(bigint) {
+ const ptr = Number(bigint & 0xffffffffn);
+ const len = Number(bigint >> 32n);
+ return decodeString(ptr, len);
+}
+
+const time_report_entry_template = document.getElementById("timeReportEntryTemplate").content;
+const domTimeReport = document.getElementById("timeReport");
+const domTimeReportList = document.getElementById("timeReportList");
+function timeReportReset(steps_len) {
+ let entries = [];
+ for (let i = 0; i < steps_len; i += 1) {
+ const step_name = unwrapString(wasm_exports.stepName(i));
+ const host = document.createElement("div");
+ const shadow = host.attachShadow({ mode: "open" });
+ shadow.appendChild(time_report_entry_template.cloneNode(true));
+ shadow.querySelector(":host > details").classList.add("pending");
+ const slotted_name = document.createElement("code");
+ slotted_name.setAttribute("slot", "step-name");
+ slotted_name.textContent = step_name;
+ host.appendChild(slotted_name);
+ entries.push(host);
+ }
+ domTimeReportList.replaceChildren(...entries);
+ domTimeReport.classList.remove("hidden");
+}
+function timeReportUpdateCompile(
+ step_idx,
+ inner_html_ptr,
+ inner_html_len,
+ file_table_html_ptr,
+ file_table_html_len,
+ decl_table_html_ptr,
+ decl_table_html_len,
+ use_llvm,
+) {
+ const inner_html = decodeString(inner_html_ptr, inner_html_len);
+ const file_table_html = decodeString(file_table_html_ptr, file_table_html_len);
+ const decl_table_html = decodeString(decl_table_html_ptr, decl_table_html_len);
+
+ const host = domTimeReportList.children.item(step_idx);
+ const shadow = host.shadowRoot;
+
+ shadow.querySelector(":host > details").classList.remove("pending", "no-llvm");
+
+ shadow.getElementById("genericReport").classList.add("hidden");
+ shadow.getElementById("compileReport").classList.remove("hidden");
+
+ if (!use_llvm) shadow.querySelector(":host > details").classList.add("no-llvm");
+ host.innerHTML = inner_html;
+ shadow.getElementById("fileTableBody").innerHTML = file_table_html;
+ shadow.getElementById("declTableBody").innerHTML = decl_table_html;
+}
+function timeReportUpdateGeneric(
+ step_idx,
+ inner_html_ptr,
+ inner_html_len,
+) {
+ const inner_html = decodeString(inner_html_ptr, inner_html_len);
+ const host = domTimeReportList.children.item(step_idx);
+ const shadow = host.shadowRoot;
+ shadow.querySelector(":host > details").classList.remove("pending", "no-llvm");
+ shadow.getElementById("genericReport").classList.remove("hidden");
+ shadow.getElementById("compileReport").classList.add("hidden");
+ host.innerHTML = inner_html;
+}
+
+const fuzz_entry_template = document.getElementById("fuzzEntryTemplate").content;
+const domFuzz = document.getElementById("fuzz");
+const domFuzzStatus = document.getElementById("fuzzStatus");
+const domFuzzEntries = document.getElementById("fuzzEntries");
+let domFuzzInstance = null;
+function fuzzRequestSources() {
+ domFuzzStatus.classList.remove("hidden");
+ domFuzzStatus.textContent = "Loading sources tarball...";
+ fetch("sources.tar").then(function(response) {
+ if (!response.ok) throw new Error("unable to download sources");
+ domFuzzStatus.textContent = "Parsing fuzz test sources...";
+ return response.arrayBuffer();
+ }).then(function(buffer) {
+ if (buffer.length === 0) throw new Error("sources.tar was empty");
+ const js_array = new Uint8Array(buffer);
+ const ptr = wasm_exports.alloc(js_array.length);
+ const wasm_array = new Uint8Array(wasm_exports.memory.buffer, ptr, js_array.length);
+ wasm_array.set(js_array);
+ wasm_exports.fuzzUnpackSources(ptr, js_array.length);
+ domFuzzStatus.textContent = "";
+ domFuzzStatus.classList.add("hidden");
+ });
+}
+function fuzzReady() {
+ domFuzz.classList.remove("hidden");
+
+ // TODO: multiple fuzzer instances
+ if (domFuzzInstance !== null) return;
+
+ const host = document.createElement("div");
+ const shadow = host.attachShadow({ mode: "open" });
+ shadow.appendChild(fuzz_entry_template.cloneNode(true));
+
+ domFuzzInstance = host;
+ domFuzzEntries.appendChild(host);
+}
+function fuzzReset() {
+ domFuzz.classList.add("hidden");
+ domFuzzEntries.replaceChildren();
+ domFuzzInstance = null;
+}
+function fuzzUpdateStats(stats_html_ptr, stats_html_len) {
+ if (domFuzzInstance === null) throw new Error("fuzzUpdateStats called when fuzzer inactive");
+ const stats_html = decodeString(stats_html_ptr, stats_html_len);
+ const host = domFuzzInstance;
+ host.innerHTML = stats_html;
+}
+function fuzzUpdateEntryPoints(entry_points_html_ptr, entry_points_html_len) {
+ if (domFuzzInstance === null) throw new Error("fuzzUpdateEntryPoints called when fuzzer inactive");
+ const entry_points_html = decodeString(entry_points_html_ptr, entry_points_html_len);
+ const domEntryPointList = domFuzzInstance.shadowRoot.getElementById("entryPointList");
+ domEntryPointList.innerHTML = entry_points_html;
+}
+function fuzzUpdateSource(source_html_ptr, source_html_len) {
+ if (domFuzzInstance === null) throw new Error("fuzzUpdateSource called when fuzzer inactive");
+ const source_html = decodeString(source_html_ptr, source_html_len);
+ const domSourceText = domFuzzInstance.shadowRoot.getElementById("sourceText");
+ domSourceText.innerHTML = source_html;
+ domFuzzInstance.shadowRoot.getElementById("source").classList.remove("hidden");
+}
+function fuzzUpdateCoverage(covered_ptr, covered_len) {
+ if (domFuzzInstance === null) throw new Error("fuzzUpdateCoverage called when fuzzer inactive");
+ const shadow = domFuzzInstance.shadowRoot;
+ const domSourceText = shadow.getElementById("sourceText");
+ const covered = getU32Array(covered_ptr, covered_len);
+ for (let i = 0; i < domSourceText.children.length; i += 1) {
+ const childDom = domSourceText.children[i];
+ if (childDom.id != null && childDom.id[0] == "l") {
+ childDom.classList.add("l");
+ childDom.classList.remove("c");
+ }
+ }
+ for (const sli of covered) {
+ shadow.getElementById(`l${sli}`).classList.add("c");
+ }
+}
diff --git a/lib/build-web/main.zig b/lib/build-web/main.zig
new file mode 100644
index 000000000000..e971f6de48e7
--- /dev/null
+++ b/lib/build-web/main.zig
@@ -0,0 +1,213 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const abi = std.Build.abi;
+const gpa = std.heap.wasm_allocator;
+const log = std.log;
+const Allocator = std.mem.Allocator;
+
+const fuzz = @import("fuzz.zig");
+const time_report = @import("time_report.zig");
+
+/// Nanoseconds.
+var server_base_timestamp: i64 = 0;
+/// Milliseconds.
+var client_base_timestamp: i64 = 0;
+
+pub var step_list: []Step = &.{};
+/// Not accessed after initialization, but must be freed alongside `step_list`.
+pub var step_list_data: []u8 = &.{};
+
+const Step = struct {
+ name: []const u8,
+ status: abi.StepUpdate.Status,
+};
+
+const js = struct {
+ extern "core" fn log(ptr: [*]const u8, len: usize) void;
+ extern "core" fn panic(ptr: [*]const u8, len: usize) noreturn;
+ extern "core" fn timestamp() i64;
+ extern "core" fn hello(
+ steps_len: u32,
+ status: abi.BuildStatus,
+ time_report: bool,
+ ) void;
+ extern "core" fn updateBuildStatus(status: abi.BuildStatus) void;
+ extern "core" fn updateStepStatus(step_idx: u32) void;
+ extern "core" fn sendWsMessage(ptr: [*]const u8, len: usize) void;
+};
+
+pub const std_options: std.Options = .{
+ .logFn = logFn,
+};
+
+pub fn panic(msg: []const u8, st: ?*std.builtin.StackTrace, addr: ?usize) noreturn {
+ _ = st;
+ _ = addr;
+ log.err("panic: {s}", .{msg});
+ @trap();
+}
+
+fn logFn(
+ comptime message_level: log.Level,
+ comptime scope: @TypeOf(.enum_literal),
+ comptime format: []const u8,
+ args: anytype,
+) void {
+ const level_txt = comptime message_level.asText();
+ const prefix2 = if (scope == .default) ": " else "(" ++ @tagName(scope) ++ "): ";
+ var buf: [500]u8 = undefined;
+ const line = std.fmt.bufPrint(&buf, level_txt ++ prefix2 ++ format, args) catch l: {
+ buf[buf.len - 3 ..][0..3].* = "...".*;
+ break :l &buf;
+ };
+ js.log(line.ptr, line.len);
+}
+
+export fn alloc(n: usize) [*]u8 {
+ const slice = gpa.alloc(u8, n) catch @panic("OOM");
+ return slice.ptr;
+}
+
+var message_buffer: std.ArrayListAlignedUnmanaged(u8, .of(u64)) = .empty;
+
+/// Resizes the message buffer to be the correct length; returns the pointer to
+/// the query string.
+export fn message_begin(len: usize) [*]u8 {
+ message_buffer.resize(gpa, len) catch @panic("OOM");
+ return message_buffer.items.ptr;
+}
+
+export fn message_end() void {
+ const msg_bytes = message_buffer.items;
+
+ const tag: abi.ToClientTag = @enumFromInt(msg_bytes[0]);
+ switch (tag) {
+ _ => @panic("malformed message"),
+
+ .hello => return helloMessage(msg_bytes) catch @panic("OOM"),
+ .status_update => return statusUpdateMessage(msg_bytes) catch @panic("OOM"),
+ .step_update => return stepUpdateMessage(msg_bytes) catch @panic("OOM"),
+
+ .fuzz_source_index => return fuzz.sourceIndexMessage(msg_bytes) catch @panic("OOM"),
+ .fuzz_coverage_update => return fuzz.coverageUpdateMessage(msg_bytes) catch @panic("OOM"),
+ .fuzz_entry_points => return fuzz.entryPointsMessage(msg_bytes) catch @panic("OOM"),
+
+ .time_report_generic_result => return time_report.genericResultMessage(msg_bytes) catch @panic("OOM"),
+ .time_report_compile_result => return time_report.compileResultMessage(msg_bytes) catch @panic("OOM"),
+ }
+}
+
+const String = Slice(u8);
+
+pub fn Slice(T: type) type {
+ return packed struct(u64) {
+ ptr: u32,
+ len: u32,
+
+ pub fn init(s: []const T) @This() {
+ return .{
+ .ptr = @intFromPtr(s.ptr),
+ .len = s.len,
+ };
+ }
+ };
+}
+
+pub fn fatal(comptime format: []const u8, args: anytype) noreturn {
+ var buf: [500]u8 = undefined;
+ const line = std.fmt.bufPrint(&buf, format, args) catch l: {
+ buf[buf.len - 3 ..][0..3].* = "...".*;
+ break :l &buf;
+ };
+ js.panic(line.ptr, line.len);
+}
+
+fn helloMessage(msg_bytes: []align(4) u8) Allocator.Error!void {
+ if (msg_bytes.len < @sizeOf(abi.Hello)) @panic("malformed Hello message");
+ const hdr: *const abi.Hello = @ptrCast(msg_bytes[0..@sizeOf(abi.Hello)]);
+ const trailing = msg_bytes[@sizeOf(abi.Hello)..];
+
+ client_base_timestamp = js.timestamp();
+ server_base_timestamp = hdr.timestamp;
+
+ const steps = try gpa.alloc(Step, hdr.steps_len);
+ errdefer gpa.free(steps);
+
+ const step_name_lens: []align(1) const u32 = @ptrCast(trailing[0 .. steps.len * 4]);
+
+ const step_name_data_len: usize = len: {
+ var sum: usize = 0;
+ for (step_name_lens) |n| sum += n;
+ break :len sum;
+ };
+ const step_name_data: []const u8 = trailing[steps.len * 4 ..][0..step_name_data_len];
+ const step_status_bits: []const u8 = trailing[steps.len * 4 + step_name_data_len ..];
+
+ const duped_step_name_data = try gpa.dupe(u8, step_name_data);
+ errdefer gpa.free(duped_step_name_data);
+
+ var name_off: usize = 0;
+ for (steps, step_name_lens, 0..) |*step_out, name_len, step_idx| {
+ step_out.* = .{
+ .name = duped_step_name_data[name_off..][0..name_len],
+ .status = @enumFromInt(@as(u2, @truncate(step_status_bits[step_idx / 4] >> @intCast((step_idx % 4) * 2)))),
+ };
+ name_off += name_len;
+ }
+
+ gpa.free(step_list);
+ gpa.free(step_list_data);
+ step_list = steps;
+ step_list_data = duped_step_name_data;
+
+ js.hello(step_list.len, hdr.status, hdr.flags.time_report);
+}
+fn statusUpdateMessage(msg_bytes: []u8) Allocator.Error!void {
+ if (msg_bytes.len < @sizeOf(abi.StatusUpdate)) @panic("malformed StatusUpdate message");
+ const msg: *const abi.StatusUpdate = @ptrCast(msg_bytes[0..@sizeOf(abi.StatusUpdate)]);
+ js.updateBuildStatus(msg.new);
+}
+fn stepUpdateMessage(msg_bytes: []u8) Allocator.Error!void {
+ if (msg_bytes.len < @sizeOf(abi.StepUpdate)) @panic("malformed StepUpdate message");
+ const msg: *const abi.StepUpdate = @ptrCast(msg_bytes[0..@sizeOf(abi.StepUpdate)]);
+ if (msg.step_idx >= step_list.len) @panic("malformed StepUpdate message");
+ step_list[msg.step_idx].status = msg.bits.status;
+ js.updateStepStatus(msg.step_idx);
+}
+
+export fn stepName(idx: usize) String {
+ return .init(step_list[idx].name);
+}
+export fn stepStatus(idx: usize) u8 {
+ return @intFromEnum(step_list[idx].status);
+}
+
+export fn rebuild() void {
+ const msg: abi.Rebuild = .{};
+ const raw: []const u8 = @ptrCast(&msg);
+ js.sendWsMessage(raw.ptr, raw.len);
+}
+
+/// Nanoseconds passed since a server timestamp.
+pub fn nsSince(server_timestamp: i64) i64 {
+ const ms_passed = js.timestamp() - client_base_timestamp;
+ const ns_passed = server_base_timestamp - server_timestamp;
+ return ns_passed + ms_passed * std.time.ns_per_ms;
+}
+
+pub fn fmtEscapeHtml(unescaped: []const u8) HtmlEscaper {
+ return .{ .unescaped = unescaped };
+}
+const HtmlEscaper = struct {
+ unescaped: []const u8,
+ pub fn format(he: HtmlEscaper, w: *std.Io.Writer) !void {
+ for (he.unescaped) |c| switch (c) {
+ '&' => try w.writeAll("&"),
+ '<' => try w.writeAll("<"),
+ '>' => try w.writeAll(">"),
+ '"' => try w.writeAll("""),
+ '\'' => try w.writeAll("'"),
+ else => try w.writeByte(c),
+ };
+ }
+};
diff --git a/lib/build-web/style.css b/lib/build-web/style.css
new file mode 100644
index 000000000000..eb89ced52707
--- /dev/null
+++ b/lib/build-web/style.css
@@ -0,0 +1,240 @@
+body {
+ font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
+ color: #000000;
+ padding: 1em 10%;
+}
+ul.no-marker {
+ list-style-type: none;
+ padding-left: 0;
+}
+hr {
+ margin: 2em 0;
+}
+.hidden {
+ display: none;
+}
+.empty-cell {
+ background: #ccc;
+}
+table.time-stats > tbody > tr > th {
+ text-align: left;
+}
+table.time-stats > tbody > tr > td {
+ text-align: right;
+}
+details > summary {
+ cursor: pointer;
+ font-size: 1.5em;
+}
+.tooltip {
+ text-decoration: underline;
+ cursor: help;
+}
+.tooltip-content {
+ border-radius: 6px;
+ display: none;
+ position: absolute;
+ background: #fff;
+ border: 1px solid black;
+ max-width: 500px;
+ padding: 1em;
+ text-align: left;
+ font-weight: normal;
+ pointer-events: none;
+}
+.tooltip:hover > .tooltip-content {
+ display: block;
+}
+table {
+ margin: 1.0em auto 1.5em 0;
+ border-collapse: collapse;
+}
+th, td {
+ padding: 0.5em 1em 0.5em 1em;
+ border: 1px solid;
+ border-color: black;
+}
+a, button {
+ color: #2A6286;
+}
+button {
+ background: #eee;
+ cursor: pointer;
+ border: none;
+ border-radius: 3px;
+ padding: 0.2em 0.5em;
+}
+button.big-btn {
+ font-size: 1.3em;
+}
+button.linkish {
+ background: none;
+ text-decoration: underline;
+ padding: 0;
+}
+button:disabled {
+ color: #888;
+ cursor: not-allowed;
+}
+pre {
+ font-family: "Source Code Pro", monospace;
+ font-size: 1em;
+ background-color: #F5F5F5;
+ padding: 1em;
+ margin: 0;
+ overflow-x: auto;
+}
+:not(pre) > code {
+ white-space: break-spaces;
+}
+code {
+ font-family: "Source Code Pro", monospace;
+ font-size: 0.9em;
+}
+code a {
+ color: #000000;
+}
+kbd {
+ color: #000;
+ background-color: #fafbfc;
+ border-color: #d1d5da;
+ border-bottom-color: #c6cbd1;
+ box-shadow-color: #c6cbd1;
+ display: inline-block;
+ padding: 0.3em 0.2em;
+ font: 1.2em monospace;
+ line-height: 0.8em;
+ vertical-align: middle;
+ border: solid 1px;
+ border-radius: 3px;
+ box-shadow: inset 0 -1px 0;
+ cursor: default;
+}
+.status-running { color: #181; }
+.status-idle { color: #444; }
+.step-success { color: #181; }
+.step-failure { color: #d11; }
+.step-wip::before {
+ content: '';
+ position: absolute;
+ margin-left: -1.5em;
+ width: 1em;
+ text-align: center;
+ animation-name: spinner;
+ animation-duration: 0.5s;
+ animation-iteration-count: infinite;
+ animation-timing-function: step-start;
+}
+@keyframes spinner {
+ 0% { content: '|'; }
+ 25% { content: '/'; }
+ 50% { content: '-'; }
+ 75% { content: '\\'; }
+ 100% { content: '|'; }
+}
+
+.l {
+ display: inline-block;
+ background: red;
+ width: 1em;
+ height: 1em;
+ border-radius: 1em;
+}
+.c {
+ background-color: green;
+}
+
+.tok-kw {
+ color: #333;
+ font-weight: bold;
+}
+.tok-str {
+ color: #d14;
+}
+.tok-builtin {
+ color: #0086b3;
+}
+.tok-comment {
+ color: #777;
+ font-style: italic;
+}
+.tok-fn {
+ color: #900;
+ font-weight: bold;
+}
+.tok-null {
+ color: #008080;
+}
+.tok-number {
+ color: #008080;
+}
+.tok-type {
+ color: #458;
+ font-weight: bold;
+}
+
+@media (prefers-color-scheme: dark) {
+ body {
+ background-color: #111;
+ color: #ddd;
+ }
+ pre {
+ background-color: #222;
+ }
+ a, button {
+ color: #88f;
+ }
+ button {
+ background: #333;
+ }
+ button:disabled {
+ color: #555;
+ }
+ code a {
+ color: #eee;
+ }
+ th, td {
+ border-color: white;
+ }
+ .empty-cell {
+ background: #000;
+ }
+ .tooltip-content {
+ background: #060606;
+ border-color: white;
+ }
+ .status-running { color: #90ee90; }
+ .status-idle { color: #bbb; }
+ .step-success { color: #90ee90; }
+ .step-failure { color: #f66; }
+ .l {
+ background-color: red;
+ }
+ .c {
+ background-color: green;
+ }
+ .tok-kw {
+ color: #eee;
+ }
+ .tok-str {
+ color: #2e5;
+ }
+ .tok-builtin {
+ color: #ff894c;
+ }
+ .tok-comment {
+ color: #aa7;
+ }
+ .tok-fn {
+ color: #B1A0F8;
+ }
+ .tok-null {
+ color: #ff8080;
+ }
+ .tok-number {
+ color: #ff8080;
+ }
+ .tok-type {
+ color: #68f;
+ }
+}
diff --git a/lib/build-web/time_report.css b/lib/build-web/time_report.css
new file mode 100644
index 000000000000..27a7c4b02238
--- /dev/null
+++ b/lib/build-web/time_report.css
@@ -0,0 +1,43 @@
+:host > details {
+ padding: 0.5em 1em;
+ background: #f2f2f2;
+ margin-bottom: 1.0em;
+ overflow-x: scroll;
+}
+:host > details.pending {
+ pointer-events: none;
+ background: #fafafa;
+ color: #666;
+}
+:host > details > div {
+ margin: 1em 2em;
+ overflow: scroll; /* we'll try to avoid overflow, but if it does happen, this makes sense */
+}
+.stats {
+ font-size: 1.2em;
+}
+details.section {
+ margin: 1.0em 0 0 0;
+}
+details.section > summary {
+ font-weight: bold;
+}
+details.section > :not(summary) {
+ margin-left: 2em;
+}
+:host > details.no-llvm .llvm-only {
+ display: none;
+}
+@media (prefers-color-scheme: dark) {
+ :host > details {
+ background: #222;
+ }
+ :host > details.pending {
+ background: #181818;
+ color: #888;
+ }
+}
+th {
+ max-width: 20em; /* don't let the 'file' column get crazy long */
+ overflow-wrap: anywhere; /* avoid overflow where possible */
+}
diff --git a/lib/build-web/time_report.zig b/lib/build-web/time_report.zig
new file mode 100644
index 000000000000..de5f9abd0c4a
--- /dev/null
+++ b/lib/build-web/time_report.zig
@@ -0,0 +1,234 @@
+const std = @import("std");
+const gpa = std.heap.wasm_allocator;
+const abi = std.Build.abi.time_report;
+const fmtEscapeHtml = @import("root").fmtEscapeHtml;
+const step_list = &@import("root").step_list;
+
+const js = struct {
+ extern "time_report" fn updateGeneric(
+ /// The index of the step.
+ step_idx: u32,
+ // The HTML which will be used to populate the template slots.
+ inner_html_ptr: [*]const u8,
+ inner_html_len: usize,
+ ) void;
+ extern "time_report" fn updateCompile(
+ /// The index of the step.
+ step_idx: u32,
+ // The HTML which will be used to populate the template slots.
+ inner_html_ptr: [*]const u8,
+ inner_html_len: usize,
+ // The HTML which will populate the of the file table.
+ file_table_html_ptr: [*]const u8,
+ file_table_html_len: usize,
+ // The HTML which will populate the of the decl table.
+ decl_table_html_ptr: [*]const u8,
+ decl_table_html_len: usize,
+ /// Whether the LLVM backend was used. If not, LLVM-specific statistics are hidden.
+ use_llvm: bool,
+ ) void;
+};
+
+pub fn genericResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
+ if (msg_bytes.len != @sizeOf(abi.GenericResult)) @panic("malformed GenericResult message");
+ const msg: *const abi.GenericResult = @ptrCast(msg_bytes);
+ if (msg.step_idx >= step_list.*.len) @panic("malformed GenericResult message");
+ const inner_html = try std.fmt.allocPrint(gpa,
+ \\{[step_name]f}
+ \\{[stat_total_time]D}
+ , .{
+ .step_name = fmtEscapeHtml(step_list.*[msg.step_idx].name),
+ .stat_total_time = msg.ns_total,
+ });
+ defer gpa.free(inner_html);
+ js.updateGeneric(msg.step_idx, inner_html.ptr, inner_html.len);
+}
+
+pub fn compileResultMessage(msg_bytes: []u8) error{OutOfMemory}!void {
+ const max_table_rows = 500;
+
+ if (msg_bytes.len < @sizeOf(abi.CompileResult)) @panic("malformed CompileResult message");
+ const hdr: *const abi.CompileResult = @ptrCast(msg_bytes[0..@sizeOf(abi.CompileResult)]);
+ if (hdr.step_idx >= step_list.*.len) @panic("malformed CompileResult message");
+ var trailing = msg_bytes[@sizeOf(abi.CompileResult)..];
+
+ const llvm_pass_timings = trailing[0..hdr.llvm_pass_timings_len];
+ trailing = trailing[hdr.llvm_pass_timings_len..];
+
+ const FileTimeReport = struct {
+ name: []const u8,
+ ns_sema: u64,
+ ns_codegen: u64,
+ ns_link: u64,
+ };
+ const DeclTimeReport = struct {
+ file_name: []const u8,
+ name: []const u8,
+ sema_count: u32,
+ ns_sema: u64,
+ ns_codegen: u64,
+ ns_link: u64,
+ };
+
+ const slowest_files = try gpa.alloc(FileTimeReport, hdr.files_len);
+ defer gpa.free(slowest_files);
+
+ const slowest_decls = try gpa.alloc(DeclTimeReport, hdr.decls_len);
+ defer gpa.free(slowest_decls);
+
+ for (slowest_files) |*file_out| {
+ const i = std.mem.indexOfScalar(u8, trailing, 0) orelse @panic("malformed CompileResult message");
+ file_out.* = .{
+ .name = trailing[0..i],
+ .ns_sema = 0,
+ .ns_codegen = 0,
+ .ns_link = 0,
+ };
+ trailing = trailing[i + 1 ..];
+ }
+
+ for (slowest_decls) |*decl_out| {
+ const i = std.mem.indexOfScalar(u8, trailing, 0) orelse @panic("malformed CompileResult message");
+ const file_idx = std.mem.readInt(u32, trailing[i..][1..5], .little);
+ const sema_count = std.mem.readInt(u32, trailing[i..][5..9], .little);
+ const sema_ns = std.mem.readInt(u64, trailing[i..][9..17], .little);
+ const codegen_ns = std.mem.readInt(u64, trailing[i..][17..25], .little);
+ const link_ns = std.mem.readInt(u64, trailing[i..][25..33], .little);
+ const file = &slowest_files[file_idx];
+ decl_out.* = .{
+ .file_name = file.name,
+ .name = trailing[0..i],
+ .sema_count = sema_count,
+ .ns_sema = sema_ns,
+ .ns_codegen = codegen_ns,
+ .ns_link = link_ns,
+ };
+ trailing = trailing[i + 33 ..];
+ file.ns_sema += sema_ns;
+ file.ns_codegen += codegen_ns;
+ file.ns_link += link_ns;
+ }
+
+ const S = struct {
+ fn fileLessThan(_: void, lhs: FileTimeReport, rhs: FileTimeReport) bool {
+ const lhs_ns = lhs.ns_sema + lhs.ns_codegen + lhs.ns_link;
+ const rhs_ns = rhs.ns_sema + rhs.ns_codegen + rhs.ns_link;
+ return lhs_ns > rhs_ns; // flipped to sort in reverse order
+ }
+ fn declLessThan(_: void, lhs: DeclTimeReport, rhs: DeclTimeReport) bool {
+ //if (true) return lhs.sema_count > rhs.sema_count;
+ const lhs_ns = lhs.ns_sema + lhs.ns_codegen + lhs.ns_link;
+ const rhs_ns = rhs.ns_sema + rhs.ns_codegen + rhs.ns_link;
+ return lhs_ns > rhs_ns; // flipped to sort in reverse order
+ }
+ };
+ std.mem.sort(FileTimeReport, slowest_files, {}, S.fileLessThan);
+ std.mem.sort(DeclTimeReport, slowest_decls, {}, S.declLessThan);
+
+ const stats = hdr.stats;
+ const inner_html = try std.fmt.allocPrint(gpa,
+ \\{[step_name]f}
+ \\{[stat_reachable_files]d}
+ \\{[stat_imported_files]d}
+ \\{[stat_generic_instances]d}
+ \\{[stat_inline_calls]d}
+ \\{[stat_compilation_time]D}
+ \\{[cpu_time_parse]D}
+ \\{[cpu_time_astgen]D}
+ \\{[cpu_time_sema]D}
+ \\{[cpu_time_codegen]D}
+ \\{[cpu_time_link]D}
+ \\{[real_time_files]D}
+ \\{[real_time_decls]D}
+ \\{[real_time_llvm_emit]D}
+ \\{[real_time_link_flush]D}
+ \\{[llvm_pass_timings]f}
+ \\ {f}{D}
+ \\ {D}
+ \\ {D}
+ \\
+ \\
+ , .{
+ fmtEscapeHtml(file.name),
+ file.ns_sema,
+ file.ns_codegen,
+ file.ns_link,
+ });
+ }
+ if (slowest_files.len > max_table_rows) {
+ try file_table_html.writer(gpa).print(
+ \\{d} more rows omitted
+ \\ {f}{f}{d}
+ \\ {D}
+ \\ {D}
+ \\ {D}
+ \\
+ \\
+ , .{
+ fmtEscapeHtml(decl.file_name),
+ fmtEscapeHtml(decl.name),
+ decl.sema_count,
+ decl.ns_sema,
+ decl.ns_codegen,
+ decl.ns_link,
+ });
+ }
+ if (slowest_decls.len > max_table_rows) {
+ try decl_table_html.writer(gpa).print(
+ \\{d} more rows omitted Delay before rebuilding after changed file detected
+ \\ --webui[=ip] Enable the web interface on the given IP address
+ \\ --fuzz Continuously search for unit test failures (implies '--webui')
+ \\ --time-report Force full rebuild and provide detailed information on
+ \\ compilation time of Zig source code (implies '--webui')
\\ -fincremental Enable incremental compilation
\\ -fno-incremental Disable incremental compilation
\\
@@ -1328,7 +1370,7 @@ fn printUsage(b: *std.Build, w: *Writer) !void {
\\
);
- const arena = b.allocator;
+ const arena = b.graph.arena;
if (b.available_options_list.items.len == 0) {
try w.print(" (none)\n", .{});
} else {
diff --git a/lib/fuzzer.zig b/lib/fuzzer.zig
index ce23f63421ac..7f1592f0de7c 100644
--- a/lib/fuzzer.zig
+++ b/lib/fuzzer.zig
@@ -3,7 +3,7 @@ const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const fatal = std.process.fatal;
-const SeenPcsHeader = std.Build.Fuzz.abi.SeenPcsHeader;
+const SeenPcsHeader = std.Build.abi.fuzz.SeenPcsHeader;
pub const std_options = std.Options{
.logFn = logOverride,
diff --git a/lib/fuzzer/web/index.html b/lib/fuzzer/web/index.html
deleted file mode 100644
index 325342e8ebf5..000000000000
--- a/lib/fuzzer/web/index.html
+++ /dev/null
@@ -1,161 +0,0 @@
-
-
-
- Zig Build System Interface
-
-
-
- Loading JavaScript...
-
-
- Total Runs:
- Unique Runs:
- Speed (Runs/Second):
- Coverage:
- Entry Points:
-
-
-- see the targets command
@@ -678,7 +679,6 @@ const usage_build_generic =
\\
\\Debug Options (Zig Compiler Development):
\\ -fopt-bisect-limit=[limit] Only run [limit] first LLVM optimization passes
- \\ -ftime-report Print timing diagnostics
\\ -fstack-report Print stack size diagnostics
\\ --verbose-link Display linker invocations
\\ --verbose-cc Display C compiler invocations
@@ -1403,7 +1403,7 @@ fn buildOutputType(
try test_exec_args.append(arena, null);
} else if (mem.eql(u8, arg, "--test-no-exec")) {
test_no_exec = true;
- } else if (mem.eql(u8, arg, "-ftime-report")) {
+ } else if (mem.eql(u8, arg, "--time-report")) {
time_report = true;
} else if (mem.eql(u8, arg, "-fstack-report")) {
stack_report = true;
@@ -2899,6 +2899,10 @@ fn buildOutputType(
fatal("test-obj requires --test-no-exec", .{});
}
+ if (time_report and listen == .none) {
+ fatal("--time-report requires --listen", .{});
+ }
+
if (arg_mode == .translate_c and create_module.c_source_files.items.len != 1) {
fatal("translate-c expects exactly 1 source file (found {d})", .{create_module.c_source_files.items.len});
}
@@ -4208,6 +4212,84 @@ fn serveUpdateResults(s: *Server, comp: *Compilation) !void {
}
}
+ if (comp.time_report) |*tr| {
+ var decls_len: u32 = 0;
+
+ var file_name_bytes: std.ArrayListUnmanaged(u8) = .empty;
+ defer file_name_bytes.deinit(gpa);
+ var files: std.AutoArrayHashMapUnmanaged(Zcu.File.Index, void) = .empty;
+ defer files.deinit(gpa);
+ var decl_data: std.ArrayListUnmanaged(u8) = .empty;
+ defer decl_data.deinit(gpa);
+
+ // Each decl needs at least 34 bytes:
+ // * 2 for 1-byte name plus null terminator
+ // * 4 for `file`
+ // * 4 for `sema_count`
+ // * 8 for `sema_ns`
+ // * 8 for `codegen_ns`
+ // * 8 for `link_ns`
+ // Most, if not all, decls in `tr.decl_sema_ns` are valid, so we have a good size estimate.
+ try decl_data.ensureUnusedCapacity(gpa, tr.decl_sema_info.count() * 34);
+
+ for (tr.decl_sema_info.keys(), tr.decl_sema_info.values()) |tracked_inst, sema_info| {
+ const resolved = tracked_inst.resolveFull(&comp.zcu.?.intern_pool) orelse continue;
+ const file = comp.zcu.?.fileByIndex(resolved.file);
+ const zir = file.zir orelse continue;
+ const decl_name = zir.nullTerminatedString(zir.getDeclaration(resolved.inst).name);
+
+ const gop = try files.getOrPut(gpa, resolved.file);
+ if (!gop.found_existing) try file_name_bytes.writer(gpa).print("{f}\x00", .{file.path.fmt(comp)});
+
+ const codegen_ns = tr.decl_codegen_ns.get(tracked_inst) orelse 0;
+ const link_ns = tr.decl_link_ns.get(tracked_inst) orelse 0;
+
+ decls_len += 1;
+
+ try decl_data.ensureUnusedCapacity(gpa, 33 + decl_name.len);
+ decl_data.appendSliceAssumeCapacity(decl_name);
+ decl_data.appendAssumeCapacity(0);
+
+ const out_file = decl_data.addManyAsArrayAssumeCapacity(4);
+ const out_sema_count = decl_data.addManyAsArrayAssumeCapacity(4);
+ const out_sema_ns = decl_data.addManyAsArrayAssumeCapacity(8);
+ const out_codegen_ns = decl_data.addManyAsArrayAssumeCapacity(8);
+ const out_link_ns = decl_data.addManyAsArrayAssumeCapacity(8);
+ std.mem.writeInt(u32, out_file, @intCast(gop.index), .little);
+ std.mem.writeInt(u32, out_sema_count, sema_info.count, .little);
+ std.mem.writeInt(u64, out_sema_ns, sema_info.ns, .little);
+ std.mem.writeInt(u64, out_codegen_ns, codegen_ns, .little);
+ std.mem.writeInt(u64, out_link_ns, link_ns, .little);
+ }
+
+ const header: std.zig.Server.Message.TimeReport = .{
+ .stats = tr.stats,
+ .llvm_pass_timings_len = @intCast(tr.llvm_pass_timings.len),
+ .files_len = @intCast(files.count()),
+ .decls_len = decls_len,
+ .flags = .{
+ .use_llvm = comp.zcu != null and comp.zcu.?.llvm_object != null,
+ },
+ };
+
+ var slices: [4][]const u8 = .{
+ @ptrCast(&header),
+ tr.llvm_pass_timings,
+ file_name_bytes.items,
+ decl_data.items,
+ };
+ try s.serveMessageHeader(.{
+ .tag = .time_report,
+ .bytes_len = len: {
+ var len: u32 = 0;
+ for (slices) |slice| len += @intCast(slice.len);
+ break :len len;
+ },
+ });
+ try s.out.writeVecAll(&slices);
+ try s.out.flush();
+ }
+
if (error_bundle.errorMessageCount() > 0) {
try s.serveErrorBundle(error_bundle);
return;
@@ -5277,7 +5359,9 @@ fn cmdBuild(gpa: Allocator, arena: Allocator, args: []const []const u8) !void {
var windows_libs: std.StringArrayHashMapUnmanaged(void) = .empty;
if (resolved_target.result.os.tag == .windows) {
- try windows_libs.put(arena, "advapi32", {});
+ try windows_libs.ensureUnusedCapacity(arena, 2);
+ windows_libs.putAssumeCapacity("advapi32", {});
+ windows_libs.putAssumeCapacity("ws2_32", {}); // for `--listen` (web interface)
}
const comp = Compilation.create(gpa, arena, .{
diff --git a/src/zig_llvm.cpp b/src/zig_llvm.cpp
index c9a30bb167e5..65dae8edcdbb 100644
--- a/src/zig_llvm.cpp
+++ b/src/zig_llvm.cpp
@@ -220,7 +220,7 @@ static SanitizerCoverageOptions getSanCovOptions(ZigLLVMCoverageOptions z) {
ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
char **error_message, const ZigLLVMEmitOptions *options)
{
- TimePassesIsEnabled = options->time_report;
+ TimePassesIsEnabled = options->time_report_out != nullptr;
raw_fd_ostream *dest_asm_ptr = nullptr;
raw_fd_ostream *dest_bin_ptr = nullptr;
@@ -418,10 +418,17 @@ ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machi
WriteBitcodeToFile(llvm_module, *dest_bitcode);
}
- if (options->time_report) {
- TimerGroup::printAll(errs());
+ // This must only happen once we know we've succeeded and will be returning `false`, because
+ // this code `malloc`s memory which will become owned by the caller (in Zig code).
+ if (options->time_report_out != nullptr) {
+ std::string out_str;
+ auto os = raw_string_ostream(out_str);
+ TimerGroup::printAll(os);
+ TimerGroup::clearAll();
+ auto c_str = (char *)malloc(out_str.length() + 1);
+ strcpy(c_str, out_str.c_str());
+ *options->time_report_out = c_str;
}
-
return false;
}
diff --git a/src/zig_llvm.h b/src/zig_llvm.h
index db331512bd90..f1940bb3408f 100644
--- a/src/zig_llvm.h
+++ b/src/zig_llvm.h
@@ -66,7 +66,10 @@ enum ZigLLVMThinOrFullLTOPhase {
struct ZigLLVMEmitOptions {
bool is_debug;
bool is_small;
- bool time_report;
+ // If not null, and `ZigLLVMTargetMachineEmitToFile` returns `false` indicating success, this
+ // `char *` will be populated with a `malloc`-allocated string containing the serialized (as
+ // JSON) time report data. The caller is responsible for freeing that memory.
+ char **time_report_out;
bool tsan;
bool sancov;
ZigLLVMThinOrFullLTOPhase lto;
diff --git a/tools/dump-cov.zig b/tools/dump-cov.zig
index 16df7e34793e..1e2444701183 100644
--- a/tools/dump-cov.zig
+++ b/tools/dump-cov.zig
@@ -5,7 +5,7 @@ const std = @import("std");
const fatal = std.process.fatal;
const Path = std.Build.Cache.Path;
const assert = std.debug.assert;
-const SeenPcsHeader = std.Build.Fuzz.abi.SeenPcsHeader;
+const SeenPcsHeader = std.Build.abi.fuzz.SeenPcsHeader;
pub fn main() !void {
var general_purpose_allocator: std.heap.GeneralPurposeAllocator(.{}) = .init;