authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2024-08-19 21:49:29-07:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2024-08-19 21:49:29-07:00
logdffc8c44f9a01aa05ea364ffdc71509d15bc2601
treeb9b610ac10bb537b8b0dfba500f6599c5e4b2e15
parent7071d1b3c2ed908bb8f1170673b50568ed56da7b
parent80999391d9b0db0303f59942cb52542a6e4da331
signaturebadge-check Signed by PGP key B5690EEEBB952194

Merge pull request #21115 from Snektron/build-system-asm

compilation and build system fixes

33 files changed, 363 insertions(+), 345 deletions(-)

lib/compiler/objcopy.zig+4-3
......@@ -201,9 +201,10 @@ fn cmdObjCopy(
201201 if (seen_update) fatal("zig objcopy only supports 1 update for now", .{});
202202 seen_update = true;
203203
204 try server.serveEmitBinPath(output, .{
205 .flags = .{ .cache_hit = false },
206 });
204 // The build system already knows what the output is at this point, we
205 // only need to communicate that the process has finished.
206 // Use the empty error bundle to indicate that the update is done.
207 try server.serveErrorBundle(std.zig.ErrorBundle.empty);
207208 },
208209 else => fatal("unsupported message: {s}", .{@tagName(hdr.tag)}),
209210 }
lib/std/Build.zig+1-1
......@@ -2373,7 +2373,7 @@ pub const LazyPath = union(enum) {
23732373 // basis for not traversing up too many directories.
23742374
23752375 var file_path: Cache.Path = .{
2376 .root_dir = gen.file.step.owner.build_root,
2376 .root_dir = Cache.Directory.cwd(),
23772377 .sub_path = gen.file.path orelse {
23782378 std.debug.lockStdErr();
23792379 const stderr = std.io.getStdErr();
lib/std/Build/Cache.zig+7-2
......@@ -896,8 +896,8 @@ pub const Manifest = struct {
896896 }
897897 }
898898
899 /// Returns a hex encoded hash of the inputs.
900 pub fn final(self: *Manifest) HexDigest {
899 /// Returns a binary hash of the inputs.
900 pub fn finalBin(self: *Manifest) BinDigest {
901901 assert(self.manifest_file != null);
902902
903903 // We don't close the manifest file yet, because we want to
......@@ -908,7 +908,12 @@ pub const Manifest = struct {
908908
909909 var bin_digest: BinDigest = undefined;
910910 self.hash.hasher.final(&bin_digest);
911 return bin_digest;
912 }
911913
914 /// Returns a hex encoded hash of the inputs.
915 pub fn final(self: *Manifest) HexDigest {
916 const bin_digest = self.finalBin();
912917 return binToHex(bin_digest);
913918 }
914919
lib/std/Build/Fuzz.zig+11-7
......@@ -100,6 +100,15 @@ pub fn start(
100100}
101101
102102fn rebuildTestsWorkerRun(run: *Step.Run, ttyconf: std.io.tty.Config, parent_prog_node: std.Progress.Node) void {
103 rebuildTestsWorkerRunFallible(run, ttyconf, parent_prog_node) catch |err| {
104 const compile = run.producer.?;
105 log.err("step '{s}': failed to rebuild in fuzz mode: {s}", .{
106 compile.step.name, @errorName(err),
107 });
108 };
109}
110
111fn rebuildTestsWorkerRunFallible(run: *Step.Run, ttyconf: std.io.tty.Config, parent_prog_node: std.Progress.Node) !void {
103112 const gpa = run.step.owner.allocator;
104113 const stderr = std.io.getStdErr();
105114
......@@ -121,14 +130,9 @@ fn rebuildTestsWorkerRun(run: *Step.Run, ttyconf: std.io.tty.Config, parent_prog
121130
122131 const rebuilt_bin_path = result catch |err| switch (err) {
123132 error.MakeFailed => return,
124 else => {
125 log.err("step '{s}': failed to rebuild in fuzz mode: {s}", .{
126 compile.step.name, @errorName(err),
127 });
128 return;
129 },
133 else => |other| return other,
130134 };
131 run.rebuilt_executable = rebuilt_bin_path;
135 run.rebuilt_executable = try rebuilt_bin_path.join(gpa, compile.out_filename);
132136}
133137
134138fn fuzzWorkerRun(
lib/std/Build/Fuzz/WebServer.zig+30-14
......@@ -8,6 +8,8 @@ const Coverage = std.debug.Coverage;
88const abi = std.Build.Fuzz.abi;
99const log = std.log;
1010const assert = std.debug.assert;
11const Cache = std.Build.Cache;
12const Path = Cache.Path;
1113
1214const WebServer = @This();
1315
......@@ -31,6 +33,10 @@ coverage_mutex: std.Thread.Mutex,
3133/// Signaled when `coverage_files` changes.
3234coverage_condition: std.Thread.Condition,
3335
36const fuzzer_bin_name = "fuzzer";
37const fuzzer_arch_os_abi = "wasm32-freestanding";
38const fuzzer_cpu_features = "baseline+atomics+bulk_memory+multivalue+mutable_globals+nontrapping_fptoint+reference_types+sign_ext";
39
3440const CoverageMap = struct {
3541 mapped_memory: []align(std.mem.page_size) const u8,
3642 coverage: Coverage,
......@@ -181,9 +187,18 @@ fn serveWasm(
181187
182188 // Do the compilation every request, so that the user can edit the files
183189 // and see the changes without restarting the server.
184 const wasm_binary_path = try buildWasmBinary(ws, arena, optimize_mode);
190 const wasm_base_path = try buildWasmBinary(ws, arena, optimize_mode);
191 const bin_name = try std.zig.binNameAlloc(arena, .{
192 .root_name = fuzzer_bin_name,
193 .target = std.zig.system.resolveTargetQuery(std.Build.parseTargetQuery(.{
194 .arch_os_abi = fuzzer_arch_os_abi,
195 .cpu_features = fuzzer_cpu_features,
196 }) catch unreachable) catch unreachable,
197 .output_mode = .Exe,
198 });
185199 // std.http.Server does not have a sendfile API yet.
186 const file_contents = try std.fs.cwd().readFileAlloc(gpa, wasm_binary_path, 10 * 1024 * 1024);
200 const bin_path = try wasm_base_path.join(arena, bin_name);
201 const file_contents = try bin_path.root_dir.handle.readFileAlloc(gpa, bin_path.sub_path, 10 * 1024 * 1024);
187202 defer gpa.free(file_contents);
188203 try request.respond(file_contents, .{
189204 .extra_headers = &.{
......@@ -197,7 +212,7 @@ fn buildWasmBinary(
197212 ws: *WebServer,
198213 arena: Allocator,
199214 optimize_mode: std.builtin.OptimizeMode,
200) ![]const u8 {
215) !Path {
201216 const gpa = ws.gpa;
202217
203218 const main_src_path: Build.Cache.Path = .{
......@@ -219,11 +234,11 @@ fn buildWasmBinary(
219234 ws.zig_exe_path, "build-exe", //
220235 "-fno-entry", //
221236 "-O", @tagName(optimize_mode), //
222 "-target", "wasm32-freestanding", //
223 "-mcpu", "baseline+atomics+bulk_memory+multivalue+mutable_globals+nontrapping_fptoint+reference_types+sign_ext", //
237 "-target", fuzzer_arch_os_abi, //
238 "-mcpu", fuzzer_cpu_features, //
224239 "--cache-dir", ws.global_cache_directory.path orelse ".", //
225240 "--global-cache-dir", ws.global_cache_directory.path orelse ".", //
226 "--name", "fuzzer", //
241 "--name", fuzzer_bin_name, //
227242 "-rdynamic", //
228243 "-fsingle-threaded", //
229244 "--dep", "Walk", //
......@@ -251,7 +266,7 @@ fn buildWasmBinary(
251266 try sendMessage(child.stdin.?, .exit);
252267
253268 const Header = std.zig.Server.Message.Header;
254 var result: ?[]const u8 = null;
269 var result: ?Path = null;
255270 var result_error_bundle = std.zig.ErrorBundle.empty;
256271
257272 const stdout = poller.fifo(.stdout);
......@@ -288,13 +303,17 @@ fn buildWasmBinary(
288303 .extra = extra_array,
289304 };
290305 },
291 .emit_bin_path => {
292 const EbpHdr = std.zig.Server.Message.EmitBinPath;
306 .emit_digest => {
307 const EbpHdr = std.zig.Server.Message.EmitDigest;
293308 const ebp_hdr = @as(*align(1) const EbpHdr, @ptrCast(body));
294309 if (!ebp_hdr.flags.cache_hit) {
295310 log.info("source changes detected; rebuilt wasm component", .{});
296311 }
297 result = try arena.dupe(u8, body[@sizeOf(EbpHdr)..]);
312 const digest = body[@sizeOf(EbpHdr)..][0..Cache.bin_digest_len];
313 result = Path{
314 .root_dir = ws.global_cache_directory,
315 .sub_path = try arena.dupe(u8, "o" ++ std.fs.path.sep_str ++ Cache.binToHex(digest.*)),
316 };
298317 },
299318 else => {}, // ignore other messages
300319 }
......@@ -568,10 +587,7 @@ fn prepareTables(
568587 };
569588 errdefer gop.value_ptr.coverage.deinit(gpa);
570589
571 const rebuilt_exe_path: Build.Cache.Path = .{
572 .root_dir = Build.Cache.Directory.cwd(),
573 .sub_path = run_step.rebuilt_executable.?,
574 };
590 const rebuilt_exe_path = run_step.rebuilt_executable.?;
575591 var debug_info = std.debug.Info.load(gpa, rebuilt_exe_path, &gop.value_ptr.coverage) catch |err| {
576592 log.err("step '{s}': failed to load debug information for '{}': {s}", .{
577593 run_step.step.name, rebuilt_exe_path, @errorName(err),
lib/std/Build/Step.zig+12-11
......@@ -317,6 +317,8 @@ const Build = std.Build;
317317const Allocator = std.mem.Allocator;
318318const assert = std.debug.assert;
319319const builtin = @import("builtin");
320const Cache = Build.Cache;
321const Path = Cache.Path;
320322
321323pub fn evalChildProcess(s: *Step, argv: []const []const u8) ![]u8 {
322324 const run_result = try captureChildProcess(s, std.Progress.Node.none, argv);
......@@ -373,7 +375,7 @@ pub fn evalZigProcess(
373375 argv: []const []const u8,
374376 prog_node: std.Progress.Node,
375377 watch: bool,
376) !?[]const u8 {
378) !?Path {
377379 if (s.getZigProcess()) |zp| update: {
378380 assert(watch);
379381 if (std.Progress.have_ipc) if (zp.progress_ipc_fd) |fd| prog_node.setIpcFd(fd);
......@@ -477,7 +479,7 @@ pub fn evalZigProcess(
477479 return result;
478480}
479481
480fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool) !?[]const u8 {
482fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool) !?Path {
481483 const b = s.owner;
482484 const arena = b.allocator;
483485
......@@ -487,7 +489,7 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool) !?[]const u8 {
487489 if (!watch) try sendMessage(zp.child.stdin.?, .exit);
488490
489491 const Header = std.zig.Server.Message.Header;
490 var result: ?[]const u8 = null;
492 var result: ?Path = null;
491493
492494 const stdout = zp.poller.fifo(.stdout);
493495
......@@ -531,16 +533,15 @@ fn zigProcessUpdate(s: *Step, zp: *ZigProcess, watch: bool) !?[]const u8 {
531533 break;
532534 }
533535 },
534 .emit_bin_path => {
535 const EbpHdr = std.zig.Server.Message.EmitBinPath;
536 .emit_digest => {
537 const EbpHdr = std.zig.Server.Message.EmitDigest;
536538 const ebp_hdr = @as(*align(1) const EbpHdr, @ptrCast(body));
537539 s.result_cached = ebp_hdr.flags.cache_hit;
538 result = try arena.dupe(u8, body[@sizeOf(EbpHdr)..]);
539 if (watch) {
540 // This message indicates the end of the update.
541 stdout.discard(body.len);
542 break;
543 }
540 const digest = body[@sizeOf(EbpHdr)..][0..Cache.bin_digest_len];
541 result = Path{
542 .root_dir = b.cache_root,
543 .sub_path = try arena.dupe(u8, "o" ++ std.fs.path.sep_str ++ Cache.binToHex(digest.*)),
544 };
544545 },
545546 .file_system_inputs => {
546547 s.clearWatchInputs();
lib/std/Build/Step/Compile.zig+14-15
......@@ -17,6 +17,7 @@ const Module = std.Build.Module;
1717const InstallDir = std.Build.InstallDir;
1818const GeneratedFile = std.Build.GeneratedFile;
1919const Compile = @This();
20const Path = std.Build.Cache.Path;
2021
2122pub const base_id: Step.Id = .compile;
2223
......@@ -1765,7 +1766,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
17651766
17661767 const zig_args = try getZigArgs(compile, false);
17671768
1768 const maybe_output_bin_path = step.evalZigProcess(
1769 const maybe_output_dir = step.evalZigProcess(
17691770 zig_args,
17701771 options.progress_node,
17711772 (b.graph.incremental == true) and options.watch,
......@@ -1779,53 +1780,51 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
17791780 };
17801781
17811782 // Update generated files
1782 if (maybe_output_bin_path) |output_bin_path| {
1783 const output_dir = fs.path.dirname(output_bin_path).?;
1784
1783 if (maybe_output_dir) |output_dir| {
17851784 if (compile.emit_directory) |lp| {
1786 lp.path = output_dir;
1785 lp.path = b.fmt("{}", .{output_dir});
17871786 }
17881787
17891788 // -femit-bin[=path] (default) Output machine code
17901789 if (compile.generated_bin) |bin| {
1791 bin.path = b.pathJoin(&.{ output_dir, compile.out_filename });
1790 bin.path = output_dir.joinString(b.allocator, compile.out_filename) catch @panic("OOM");
17921791 }
17931792
1794 const sep = std.fs.path.sep;
1793 const sep = std.fs.path.sep_str;
17951794
17961795 // output PDB if someone requested it
17971796 if (compile.generated_pdb) |pdb| {
1798 pdb.path = b.fmt("{s}{c}{s}.pdb", .{ output_dir, sep, compile.name });
1797 pdb.path = b.fmt("{}" ++ sep ++ "{s}.pdb", .{ output_dir, compile.name });
17991798 }
18001799
18011800 // -femit-implib[=path] (default) Produce an import .lib when building a Windows DLL
18021801 if (compile.generated_implib) |implib| {
1803 implib.path = b.fmt("{s}{c}{s}.lib", .{ output_dir, sep, compile.name });
1802 implib.path = b.fmt("{}" ++ sep ++ "{s}.lib", .{ output_dir, compile.name });
18041803 }
18051804
18061805 // -femit-h[=path] Generate a C header file (.h)
18071806 if (compile.generated_h) |lp| {
1808 lp.path = b.fmt("{s}{c}{s}.h", .{ output_dir, sep, compile.name });
1807 lp.path = b.fmt("{}" ++ sep ++ "{s}.h", .{ output_dir, compile.name });
18091808 }
18101809
18111810 // -femit-docs[=path] Create a docs/ dir with html documentation
18121811 if (compile.generated_docs) |generated_docs| {
1813 generated_docs.path = b.pathJoin(&.{ output_dir, "docs" });
1812 generated_docs.path = output_dir.joinString(b.allocator, "docs") catch @panic("OOM");
18141813 }
18151814
18161815 // -femit-asm[=path] Output .s (assembly code)
18171816 if (compile.generated_asm) |lp| {
1818 lp.path = b.fmt("{s}{c}{s}.s", .{ output_dir, sep, compile.name });
1817 lp.path = b.fmt("{}" ++ sep ++ "{s}.s", .{ output_dir, compile.name });
18191818 }
18201819
18211820 // -femit-llvm-ir[=path] Produce a .ll file with optimized LLVM IR (requires LLVM extensions)
18221821 if (compile.generated_llvm_ir) |lp| {
1823 lp.path = b.fmt("{s}{c}{s}.ll", .{ output_dir, sep, compile.name });
1822 lp.path = b.fmt("{}" ++ sep ++ "{s}.ll", .{ output_dir, compile.name });
18241823 }
18251824
18261825 // -femit-llvm-bc[=path] Produce an optimized LLVM module as a .bc file (requires LLVM extensions)
18271826 if (compile.generated_llvm_bc) |lp| {
1828 lp.path = b.fmt("{s}{c}{s}.bc", .{ output_dir, sep, compile.name });
1827 lp.path = b.fmt("{}" ++ sep ++ "{s}.bc", .{ output_dir, compile.name });
18291828 }
18301829 }
18311830
......@@ -1841,7 +1840,7 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
18411840 }
18421841}
18431842
1844pub fn rebuildInFuzzMode(c: *Compile, progress_node: std.Progress.Node) ![]const u8 {
1843pub fn rebuildInFuzzMode(c: *Compile, progress_node: std.Progress.Node) !Path {
18451844 const gpa = c.step.owner.allocator;
18461845
18471846 c.step.result_error_msgs.clearRetainingCapacity();
lib/std/Build/Step/InstallArtifact.zig+25-24
......@@ -125,10 +125,10 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
125125
126126 if (install_artifact.dest_dir) |dest_dir| {
127127 const full_dest_path = b.getInstallPath(dest_dir, install_artifact.dest_sub_path);
128 const full_src_path = install_artifact.emitted_bin.?.getPath2(b, step);
129 const p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_dest_path, .{}) catch |err| {
128 const src_path = install_artifact.emitted_bin.?.getPath3(b, step);
129 const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_dest_path, .{}) catch |err| {
130130 return step.fail("unable to update file from '{s}' to '{s}': {s}", .{
131 full_src_path, full_dest_path, @errorName(err),
131 src_path.sub_path, full_dest_path, @errorName(err),
132132 });
133133 };
134134 all_cached = all_cached and p == .fresh;
......@@ -141,22 +141,22 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
141141 }
142142
143143 if (install_artifact.implib_dir) |implib_dir| {
144 const full_src_path = install_artifact.emitted_implib.?.getPath2(b, step);
145 const full_implib_path = b.getInstallPath(implib_dir, fs.path.basename(full_src_path));
146 const p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_implib_path, .{}) catch |err| {
144 const src_path = install_artifact.emitted_implib.?.getPath3(b, step);
145 const full_implib_path = b.getInstallPath(implib_dir, fs.path.basename(src_path.sub_path));
146 const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_implib_path, .{}) catch |err| {
147147 return step.fail("unable to update file from '{s}' to '{s}': {s}", .{
148 full_src_path, full_implib_path, @errorName(err),
148 src_path.sub_path, full_implib_path, @errorName(err),
149149 });
150150 };
151151 all_cached = all_cached and p == .fresh;
152152 }
153153
154154 if (install_artifact.pdb_dir) |pdb_dir| {
155 const full_src_path = install_artifact.emitted_pdb.?.getPath2(b, step);
156 const full_pdb_path = b.getInstallPath(pdb_dir, fs.path.basename(full_src_path));
157 const p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_pdb_path, .{}) catch |err| {
155 const src_path = install_artifact.emitted_pdb.?.getPath3(b, step);
156 const full_pdb_path = b.getInstallPath(pdb_dir, fs.path.basename(src_path.sub_path));
157 const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_pdb_path, .{}) catch |err| {
158158 return step.fail("unable to update file from '{s}' to '{s}': {s}", .{
159 full_src_path, full_pdb_path, @errorName(err),
159 src_path.sub_path, full_pdb_path, @errorName(err),
160160 });
161161 };
162162 all_cached = all_cached and p == .fresh;
......@@ -164,11 +164,11 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
164164
165165 if (install_artifact.h_dir) |h_dir| {
166166 if (install_artifact.emitted_h) |emitted_h| {
167 const full_src_path = emitted_h.getPath2(b, step);
168 const full_h_path = b.getInstallPath(h_dir, fs.path.basename(full_src_path));
169 const p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_h_path, .{}) catch |err| {
167 const src_path = emitted_h.getPath3(b, step);
168 const full_h_path = b.getInstallPath(h_dir, fs.path.basename(src_path.sub_path));
169 const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_h_path, .{}) catch |err| {
170170 return step.fail("unable to update file from '{s}' to '{s}': {s}", .{
171 full_src_path, full_h_path, @errorName(err),
171 src_path.sub_path, full_h_path, @errorName(err),
172172 });
173173 };
174174 all_cached = all_cached and p == .fresh;
......@@ -176,22 +176,22 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
176176
177177 for (install_artifact.artifact.installed_headers.items) |installation| switch (installation) {
178178 .file => |file| {
179 const full_src_path = file.source.getPath2(b, step);
179 const src_path = file.source.getPath3(b, step);
180180 const full_h_path = b.getInstallPath(h_dir, file.dest_rel_path);
181 const p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_h_path, .{}) catch |err| {
181 const p = fs.Dir.updateFile(src_path.root_dir.handle, src_path.sub_path, cwd, full_h_path, .{}) catch |err| {
182182 return step.fail("unable to update file from '{s}' to '{s}': {s}", .{
183 full_src_path, full_h_path, @errorName(err),
183 src_path.sub_path, full_h_path, @errorName(err),
184184 });
185185 };
186186 all_cached = all_cached and p == .fresh;
187187 },
188188 .directory => |dir| {
189 const full_src_dir_path = dir.source.getPath2(b, step);
189 const src_dir_path = dir.source.getPath3(b, step);
190190 const full_h_prefix = b.getInstallPath(h_dir, dir.dest_rel_path);
191191
192 var src_dir = b.build_root.handle.openDir(full_src_dir_path, .{ .iterate = true }) catch |err| {
192 var src_dir = src_dir_path.root_dir.handle.openDir(src_dir_path.sub_path, .{ .iterate = true }) catch |err| {
193193 return step.fail("unable to open source directory '{s}': {s}", .{
194 full_src_dir_path, @errorName(err),
194 src_dir_path.sub_path, @errorName(err),
195195 });
196196 };
197197 defer src_dir.close();
......@@ -208,14 +208,15 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
208208 continue :next_entry;
209209 }
210210 }
211 const full_src_entry_path = b.pathJoin(&.{ full_src_dir_path, entry.path });
211
212 const src_entry_path = src_dir_path.join(b.allocator, entry.path) catch @panic("OOM");
212213 const full_dest_path = b.pathJoin(&.{ full_h_prefix, entry.path });
213214 switch (entry.kind) {
214215 .directory => try cwd.makePath(full_dest_path),
215216 .file => {
216 const p = fs.Dir.updateFile(cwd, full_src_entry_path, cwd, full_dest_path, .{}) catch |err| {
217 const p = fs.Dir.updateFile(src_entry_path.root_dir.handle, src_entry_path.sub_path, cwd, full_dest_path, .{}) catch |err| {
217218 return step.fail("unable to update file from '{s}' to '{s}': {s}", .{
218 full_src_entry_path, full_dest_path, @errorName(err),
219 src_entry_path.sub_path, full_dest_path, @errorName(err),
219220 });
220221 };
221222 all_cached = all_cached and p == .fresh;
lib/std/Build/Step/Run.zig+3-2
......@@ -7,6 +7,7 @@ const mem = std.mem;
77const process = std.process;
88const EnvMap = process.EnvMap;
99const assert = std.debug.assert;
10const Path = Build.Cache.Path;
1011
1112const Run = @This();
1213
......@@ -93,7 +94,7 @@ cached_test_metadata: ?CachedTestMetadata = null,
9394
9495/// Populated during the fuzz phase if this run step corresponds to a unit test
9596/// executable that contains fuzz tests.
96rebuilt_executable: ?[]const u8,
97rebuilt_executable: ?Path,
9798
9899/// If this Run step was produced by a Compile step, it is tracked here.
99100producer: ?*Step.Compile,
......@@ -872,7 +873,7 @@ pub fn rerunInFuzzMode(
872873 .artifact => |pa| {
873874 const artifact = pa.artifact;
874875 const file_path = if (artifact == run.producer.?)
875 run.rebuilt_executable.?
876 b.fmt("{}", .{run.rebuilt_executable.?})
876877 else
877878 (artifact.installed_path orelse artifact.generated_bin.?.path.?);
878879 try argv_list.append(arena, b.fmt("{s}{s}", .{ pa.prefix, file_path }));
lib/std/Build/Step/TranslateC.zig+6-6
......@@ -153,12 +153,12 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
153153 try argv_list.append(c_macro);
154154 }
155155
156 try argv_list.append(translate_c.source.getPath2(b, step));
156 const c_source_path = translate_c.source.getPath2(b, step);
157 try argv_list.append(c_source_path);
157158
158 const output_path = try step.evalZigProcess(argv_list.items, prog_node, false);
159 const output_dir = try step.evalZigProcess(argv_list.items, prog_node, false);
159160
160 translate_c.out_basename = fs.path.basename(output_path.?);
161 const output_dir = fs.path.dirname(output_path.?).?;
162
163 translate_c.output_file.path = b.pathJoin(&.{ output_dir, translate_c.out_basename });
161 const basename = std.fs.path.stem(std.fs.path.basename(c_source_path));
162 translate_c.out_basename = b.fmt("{s}.zig", .{basename});
163 translate_c.output_file.path = output_dir.?.joinString(b.allocator, translate_c.out_basename) catch @panic("OOM");
164164}
lib/std/zig/Server.zig+11-10
......@@ -14,8 +14,8 @@ pub const Message = struct {
1414 zig_version,
1515 /// Body is an ErrorBundle.
1616 error_bundle,
17 /// Body is a EmitBinPath.
18 emit_bin_path,
17 /// Body is a EmitDigest.
18 emit_digest,
1919 /// Body is a TestMetadata
2020 test_metadata,
2121 /// Body is a TestResults
......@@ -82,8 +82,8 @@ pub const Message = struct {
8282 };
8383
8484 /// Trailing:
85 /// * file system path where the emitted binary can be found
86 pub const EmitBinPath = extern struct {
85 /// * the hex digest of the cache directory within the /o/ subdirectory.
86 pub const EmitDigest = extern struct {
8787 flags: Flags,
8888
8989 pub const Flags = packed struct(u8) {
......@@ -196,17 +196,17 @@ pub fn serveU64Message(s: *Server, tag: OutMessage.Tag, int: u64) !void {
196196 }, &.{std.mem.asBytes(&msg_le)});
197197}
198198
199pub fn serveEmitBinPath(
199pub fn serveEmitDigest(
200200 s: *Server,
201 fs_path: []const u8,
202 header: OutMessage.EmitBinPath,
201 digest: *const [Cache.bin_digest_len]u8,
202 header: OutMessage.EmitDigest,
203203) !void {
204204 try s.serveMessage(.{
205 .tag = .emit_bin_path,
206 .bytes_len = @intCast(fs_path.len + @sizeOf(OutMessage.EmitBinPath)),
205 .tag = .emit_digest,
206 .bytes_len = @intCast(digest.len + @sizeOf(OutMessage.EmitDigest)),
207207 }, &.{
208208 std.mem.asBytes(&header),
209 fs_path,
209 digest,
210210 });
211211}
212212
......@@ -328,3 +328,4 @@ const Allocator = std.mem.Allocator;
328328const assert = std.debug.assert;
329329const native_endian = builtin.target.cpu.arch.endian();
330330const need_bswap = native_endian != .little;
331const Cache = std.Build.Cache;
src/Compilation.zig+68-88
......@@ -39,6 +39,8 @@ const Air = @import("Air.zig");
3939const Builtin = @import("Builtin.zig");
4040const LlvmObject = @import("codegen/llvm.zig").Object;
4141const dev = @import("dev.zig");
42pub const Directory = Cache.Directory;
43const Path = Cache.Path;
4244
4345pub const Config = @import("Compilation/Config.zig");
4446
......@@ -70,9 +72,9 @@ bin_file: ?*link.File,
7072/// The root path for the dynamic linker and system libraries (as well as frameworks on Darwin)
7173sysroot: ?[]const u8,
7274/// This is `null` when not building a Windows DLL, or when `-fno-emit-implib` is used.
73implib_emit: ?Emit,
75implib_emit: ?Path,
7476/// This is non-null when `-femit-docs` is provided.
75docs_emit: ?Emit,
77docs_emit: ?Path,
7678root_name: [:0]const u8,
7779include_compiler_rt: bool,
7880objects: []Compilation.LinkObject,
......@@ -269,27 +271,9 @@ llvm_opt_bisect_limit: c_int,
269271
270272file_system_inputs: ?*std.ArrayListUnmanaged(u8),
271273
272pub const Emit = struct {
273 /// Where the output will go.
274 directory: Directory,
275 /// Path to the output file, relative to `directory`.
276 sub_path: []const u8,
277
278 /// Returns the full path to `basename` if it were in the same directory as the
279 /// `Emit` sub_path.
280 pub fn basenamePath(emit: Emit, arena: Allocator, basename: []const u8) ![:0]const u8 {
281 const full_path = if (emit.directory.path) |p|
282 try std.fs.path.join(arena, &[_][]const u8{ p, emit.sub_path })
283 else
284 emit.sub_path;
285
286 if (std.fs.path.dirname(full_path)) |dirname| {
287 return try std.fs.path.joinZ(arena, &.{ dirname, basename });
288 } else {
289 return try arena.dupeZ(u8, basename);
290 }
291 }
292};
274/// This is the digest of the cache for the current compilation.
275/// This digest will be known after update() is called.
276digest: ?[Cache.bin_digest_len]u8 = null,
293277
294278pub const default_stack_protector_buffer_size = target_util.default_stack_protector_buffer_size;
295279pub const SemaError = Zcu.SemaError;
......@@ -868,8 +852,6 @@ pub const LldError = struct {
868852 }
869853};
870854
871pub const Directory = Cache.Directory;
872
873855pub const EmitLoc = struct {
874856 /// If this is `null` it means the file will be output to the cache directory.
875857 /// When provided, both the open file handle and the path name must outlive the `Compilation`.
......@@ -1672,7 +1654,9 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
16721654 // In the case of incremental cache mode, this `artifact_directory`
16731655 // is computed based on a hash of non-linker inputs, and it is where all
16741656 // build artifacts are stored (even while in-progress).
1657 comp.digest = hash.peekBin();
16751658 const digest = hash.final();
1659
16761660 const artifact_sub_dir = "o" ++ std.fs.path.sep_str ++ digest;
16771661 var artifact_dir = try options.local_cache_directory.handle.makeOpenPath(artifact_sub_dir, .{});
16781662 errdefer artifact_dir.close();
......@@ -1688,8 +1672,8 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
16881672 comp.cache_use = .{ .incremental = incremental };
16891673
16901674 if (options.emit_bin) |emit_bin| {
1691 const emit: Emit = .{
1692 .directory = emit_bin.directory orelse artifact_directory,
1675 const emit: Path = .{
1676 .root_dir = emit_bin.directory orelse artifact_directory,
16931677 .sub_path = emit_bin.basename,
16941678 };
16951679 comp.bin_file = try link.File.open(arena, comp, emit, lf_open_opts);
......@@ -1697,14 +1681,14 @@ pub fn create(gpa: Allocator, arena: Allocator, options: CreateOptions) !*Compil
16971681
16981682 if (options.emit_implib) |emit_implib| {
16991683 comp.implib_emit = .{
1700 .directory = emit_implib.directory orelse artifact_directory,
1684 .root_dir = emit_implib.directory orelse artifact_directory,
17011685 .sub_path = emit_implib.basename,
17021686 };
17031687 }
17041688
17051689 if (options.emit_docs) |emit_docs| {
17061690 comp.docs_emit = .{
1707 .directory = emit_docs.directory orelse artifact_directory,
1691 .root_dir = emit_docs.directory orelse artifact_directory,
17081692 .sub_path = emit_docs.basename,
17091693 };
17101694 }
......@@ -2121,9 +2105,11 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
21212105
21222106 comp.last_update_was_cache_hit = true;
21232107 log.debug("CacheMode.whole cache hit for {s}", .{comp.root_name});
2124 const digest = man.final();
2108 const bin_digest = man.finalBin();
2109 const hex_digest = Cache.binToHex(bin_digest);
21252110
2126 comp.wholeCacheModeSetBinFilePath(whole, &digest);
2111 comp.digest = bin_digest;
2112 comp.wholeCacheModeSetBinFilePath(whole, &hex_digest);
21272113
21282114 assert(whole.lock == null);
21292115 whole.lock = man.toOwnedLock();
......@@ -2155,21 +2141,21 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
21552141
21562142 if (whole.implib_sub_path) |sub_path| {
21572143 comp.implib_emit = .{
2158 .directory = tmp_artifact_directory,
2144 .root_dir = tmp_artifact_directory,
21592145 .sub_path = std.fs.path.basename(sub_path),
21602146 };
21612147 }
21622148
21632149 if (whole.docs_sub_path) |sub_path| {
21642150 comp.docs_emit = .{
2165 .directory = tmp_artifact_directory,
2151 .root_dir = tmp_artifact_directory,
21662152 .sub_path = std.fs.path.basename(sub_path),
21672153 };
21682154 }
21692155
21702156 if (whole.bin_sub_path) |sub_path| {
2171 const emit: Emit = .{
2172 .directory = tmp_artifact_directory,
2157 const emit: Path = .{
2158 .root_dir = tmp_artifact_directory,
21732159 .sub_path = std.fs.path.basename(sub_path),
21742160 };
21752161 comp.bin_file = try link.File.createEmpty(arena, comp, emit, whole.lf_open_opts);
......@@ -2329,7 +2315,8 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
23292315 try man.populateOtherManifest(pwc.manifest, pwc.prefix_map);
23302316 }
23312317
2332 const digest = man.final();
2318 const bin_digest = man.finalBin();
2319 const hex_digest = Cache.binToHex(bin_digest);
23332320
23342321 // Rename the temporary directory into place.
23352322 // Close tmp dir and link.File to avoid open handle during rename.
......@@ -2341,7 +2328,7 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
23412328
23422329 const s = std.fs.path.sep_str;
23432330 const tmp_dir_sub_path = "tmp" ++ s ++ std.fmt.hex(tmp_dir_rand_int);
2344 const o_sub_path = "o" ++ s ++ digest;
2331 const o_sub_path = "o" ++ s ++ hex_digest;
23452332
23462333 // Work around windows `AccessDenied` if any files within this
23472334 // directory are open by closing and reopening the file handles.
......@@ -2376,14 +2363,15 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
23762363 },
23772364 );
23782365 };
2379 comp.wholeCacheModeSetBinFilePath(whole, &digest);
2366 comp.digest = bin_digest;
2367 comp.wholeCacheModeSetBinFilePath(whole, &hex_digest);
23802368
23812369 // The linker flush functions need to know the final output path
23822370 // for debug info purposes because executable debug info contains
23832371 // references object file paths.
23842372 if (comp.bin_file) |lf| {
23852373 lf.emit = .{
2386 .directory = comp.local_cache_directory,
2374 .root_dir = comp.local_cache_directory,
23872375 .sub_path = whole.bin_sub_path.?,
23882376 };
23892377
......@@ -2393,9 +2381,10 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
23932381 }
23942382 }
23952383
2396 try flush(comp, arena, .main, main_progress_node);
2397
2398 if (try comp.totalErrorCount() != 0) return;
2384 try flush(comp, arena, .{
2385 .root_dir = comp.local_cache_directory,
2386 .sub_path = o_sub_path,
2387 }, .main, main_progress_node);
23992388
24002389 // Failure here only means an unnecessary cache miss.
24012390 man.writeManifest() catch |err| {
......@@ -2410,8 +2399,10 @@ pub fn update(comp: *Compilation, main_progress_node: std.Progress.Node) !void {
24102399 assert(whole.lock == null);
24112400 whole.lock = man.toOwnedLock();
24122401 },
2413 .incremental => {
2414 try flush(comp, arena, .main, main_progress_node);
2402 .incremental => |incremental| {
2403 try flush(comp, arena, .{
2404 .root_dir = incremental.artifact_directory,
2405 }, .main, main_progress_node);
24152406 },
24162407 }
24172408}
......@@ -2440,7 +2431,13 @@ pub fn appendFileSystemInput(
24402431 std.debug.panic("missing prefix directory: {}, {s}", .{ root, sub_file_path });
24412432}
24422433
2443fn flush(comp: *Compilation, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: std.Progress.Node) !void {
2434fn flush(
2435 comp: *Compilation,
2436 arena: Allocator,
2437 default_artifact_directory: Path,
2438 tid: Zcu.PerThread.Id,
2439 prog_node: std.Progress.Node,
2440) !void {
24442441 if (comp.bin_file) |lf| {
24452442 // This is needed before reading the error flags.
24462443 lf.flush(arena, tid, prog_node) catch |err| switch (err) {
......@@ -2454,17 +2451,7 @@ fn flush(comp: *Compilation, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
24542451 try link.File.C.flushEmitH(zcu);
24552452
24562453 if (zcu.llvm_object) |llvm_object| {
2457 const default_emit = switch (comp.cache_use) {
2458 .whole => |whole| .{
2459 .directory = whole.tmp_artifact_directory.?,
2460 .sub_path = "dummy",
2461 },
2462 .incremental => |incremental| .{
2463 .directory = incremental.artifact_directory,
2464 .sub_path = "dummy",
2465 },
2466 };
2467 try emitLlvmObject(comp, arena, default_emit, null, llvm_object, prog_node);
2454 try emitLlvmObject(comp, arena, default_artifact_directory, null, llvm_object, prog_node);
24682455 }
24692456 }
24702457}
......@@ -2533,7 +2520,7 @@ fn wholeCacheModeSetBinFilePath(
25332520 @memcpy(sub_path[digest_start..][0..digest.len], digest);
25342521
25352522 comp.implib_emit = .{
2536 .directory = comp.local_cache_directory,
2523 .root_dir = comp.local_cache_directory,
25372524 .sub_path = sub_path,
25382525 };
25392526 }
......@@ -2542,7 +2529,7 @@ fn wholeCacheModeSetBinFilePath(
25422529 @memcpy(sub_path[digest_start..][0..digest.len], digest);
25432530
25442531 comp.docs_emit = .{
2545 .directory = comp.local_cache_directory,
2532 .root_dir = comp.local_cache_directory,
25462533 .sub_path = sub_path,
25472534 };
25482535 }
......@@ -2745,7 +2732,7 @@ fn emitOthers(comp: *Compilation) void {
27452732pub fn emitLlvmObject(
27462733 comp: *Compilation,
27472734 arena: Allocator,
2748 default_emit: Emit,
2735 default_artifact_directory: Path,
27492736 bin_emit_loc: ?EmitLoc,
27502737 llvm_object: LlvmObject.Ptr,
27512738 prog_node: std.Progress.Node,
......@@ -2756,10 +2743,10 @@ pub fn emitLlvmObject(
27562743 try llvm_object.emit(.{
27572744 .pre_ir_path = comp.verbose_llvm_ir,
27582745 .pre_bc_path = comp.verbose_llvm_bc,
2759 .bin_path = try resolveEmitLoc(arena, default_emit, bin_emit_loc),
2760 .asm_path = try resolveEmitLoc(arena, default_emit, comp.emit_asm),
2761 .post_ir_path = try resolveEmitLoc(arena, default_emit, comp.emit_llvm_ir),
2762 .post_bc_path = try resolveEmitLoc(arena, default_emit, comp.emit_llvm_bc),
2746 .bin_path = try resolveEmitLoc(arena, default_artifact_directory, bin_emit_loc),
2747 .asm_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_asm),
2748 .post_ir_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_llvm_ir),
2749 .post_bc_path = try resolveEmitLoc(arena, default_artifact_directory, comp.emit_llvm_bc),
27632750
27642751 .is_debug = comp.root_mod.optimize_mode == .Debug,
27652752 .is_small = comp.root_mod.optimize_mode == .ReleaseSmall,
......@@ -2772,14 +2759,14 @@ pub fn emitLlvmObject(
27722759
27732760fn resolveEmitLoc(
27742761 arena: Allocator,
2775 default_emit: Emit,
2762 default_artifact_directory: Path,
27762763 opt_loc: ?EmitLoc,
27772764) Allocator.Error!?[*:0]const u8 {
27782765 const loc = opt_loc orelse return null;
27792766 const slice = if (loc.directory) |directory|
27802767 try directory.joinZ(arena, &.{loc.basename})
27812768 else
2782 try default_emit.basenamePath(arena, loc.basename);
2769 try default_artifact_directory.joinStringZ(arena, loc.basename);
27832770 return slice.ptr;
27842771}
27852772
......@@ -3035,7 +3022,7 @@ pub fn saveState(comp: *Compilation) !void {
30353022
30363023 // Using an atomic file prevents a crash or power failure from corrupting
30373024 // the previous incremental compilation state.
3038 var af = try lf.emit.directory.handle.atomicFile(basename, .{});
3025 var af = try lf.emit.root_dir.handle.atomicFile(basename, .{});
30393026 defer af.deinit();
30403027 try af.file.pwritevAll(bufs.items, 0);
30413028 try af.finish();
......@@ -4000,11 +3987,11 @@ fn docsCopyFallible(comp: *Compilation) anyerror!void {
40003987 return comp.lockAndSetMiscFailure(.docs_copy, "no Zig code to document", .{});
40013988
40023989 const emit = comp.docs_emit.?;
4003 var out_dir = emit.directory.handle.makeOpenPath(emit.sub_path, .{}) catch |err| {
3990 var out_dir = emit.root_dir.handle.makeOpenPath(emit.sub_path, .{}) catch |err| {
40043991 return comp.lockAndSetMiscFailure(
40053992 .docs_copy,
40063993 "unable to create output directory '{}{s}': {s}",
4007 .{ emit.directory, emit.sub_path, @errorName(err) },
3994 .{ emit.root_dir, emit.sub_path, @errorName(err) },
40083995 );
40093996 };
40103997 defer out_dir.close();
......@@ -4024,7 +4011,7 @@ fn docsCopyFallible(comp: *Compilation) anyerror!void {
40244011 return comp.lockAndSetMiscFailure(
40254012 .docs_copy,
40264013 "unable to create '{}{s}/sources.tar': {s}",
4027 .{ emit.directory, emit.sub_path, @errorName(err) },
4014 .{ emit.root_dir, emit.sub_path, @errorName(err) },
40284015 );
40294016 };
40304017 defer tar_file.close();
......@@ -4223,11 +4210,11 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) anye
42234210 try comp.updateSubCompilation(sub_compilation, .docs_wasm, prog_node);
42244211
42254212 const emit = comp.docs_emit.?;
4226 var out_dir = emit.directory.handle.makeOpenPath(emit.sub_path, .{}) catch |err| {
4213 var out_dir = emit.root_dir.handle.makeOpenPath(emit.sub_path, .{}) catch |err| {
42274214 return comp.lockAndSetMiscFailure(
42284215 .docs_copy,
42294216 "unable to create output directory '{}{s}': {s}",
4230 .{ emit.directory, emit.sub_path, @errorName(err) },
4217 .{ emit.root_dir, emit.sub_path, @errorName(err) },
42314218 );
42324219 };
42334220 defer out_dir.close();
......@@ -4241,7 +4228,7 @@ fn workerDocsWasmFallible(comp: *Compilation, prog_node: std.Progress.Node) anye
42414228 return comp.lockAndSetMiscFailure(.docs_copy, "unable to copy '{}{s}' to '{}{s}': {s}", .{
42424229 sub_compilation.local_cache_directory,
42434230 sub_compilation.cache_use.whole.bin_sub_path.?,
4244 emit.directory,
4231 emit.root_dir,
42454232 emit.sub_path,
42464233 @errorName(err),
42474234 });
......@@ -4403,7 +4390,7 @@ pub fn obtainWin32ResourceCacheManifest(comp: *const Compilation) Cache.Manifest
44034390}
44044391
44054392pub const CImportResult = struct {
4406 out_zig_path: []u8,
4393 digest: [Cache.bin_digest_len]u8,
44074394 cache_hit: bool,
44084395 errors: std.zig.ErrorBundle,
44094396
......@@ -4413,8 +4400,6 @@ pub const CImportResult = struct {
44134400};
44144401
44154402/// Caller owns returned memory.
4416/// This API is currently coupled pretty tightly to stage1's needs; it will need to be reworked
4417/// a bit when we want to start using it from self-hosted.
44184403pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module) !CImportResult {
44194404 dev.check(.translate_c_command);
44204405
......@@ -4503,7 +4488,7 @@ pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module
45034488 error.OutOfMemory => return error.OutOfMemory,
45044489 error.SemanticAnalyzeFail => {
45054490 return CImportResult{
4506 .out_zig_path = "",
4491 .digest = undefined,
45074492 .cache_hit = actual_hit,
45084493 .errors = errors,
45094494 };
......@@ -4528,8 +4513,9 @@ pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module
45284513 .incremental => {},
45294514 }
45304515
4531 const digest = man.final();
4532 const o_sub_path = try std.fs.path.join(arena, &[_][]const u8{ "o", &digest });
4516 const bin_digest = man.finalBin();
4517 const hex_digest = Cache.binToHex(bin_digest);
4518 const o_sub_path = "o" ++ std.fs.path.sep_str ++ hex_digest;
45334519 var o_dir = try comp.local_cache_directory.handle.makeOpenPath(o_sub_path, .{});
45344520 defer o_dir.close();
45354521
......@@ -4541,8 +4527,8 @@ pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module
45414527
45424528 try out_zig_file.writeAll(formatted);
45434529
4544 break :digest digest;
4545 } else man.final();
4530 break :digest bin_digest;
4531 } else man.finalBin();
45464532
45474533 if (man.have_exclusive_lock) {
45484534 // Write the updated manifest. This is a no-op if the manifest is not dirty. Note that it is
......@@ -4554,14 +4540,8 @@ pub fn cImport(comp: *Compilation, c_src: []const u8, owner_mod: *Package.Module
45544540 };
45554541 }
45564542
4557 const out_zig_path = try comp.local_cache_directory.join(comp.arena, &.{
4558 "o", &digest, cimport_zig_basename,
4559 });
4560 if (comp.verbose_cimport) {
4561 log.info("C import output: {s}", .{out_zig_path});
4562 }
45634543 return CImportResult{
4564 .out_zig_path = out_zig_path,
4544 .digest = digest,
45654545 .cache_hit = actual_hit,
45664546 .errors = std.zig.ErrorBundle.empty,
45674547 };
......@@ -4800,7 +4780,7 @@ fn updateCObject(comp: *Compilation, c_object: *CObject, c_obj_prog_node: std.Pr
48004780 try argv.appendSlice(c_object.src.cache_exempt_flags);
48014781
48024782 const out_obj_path = if (comp.bin_file) |lf|
4803 try lf.emit.directory.join(arena, &.{lf.emit.sub_path})
4783 try lf.emit.root_dir.join(arena, &.{lf.emit.sub_path})
48044784 else
48054785 "/dev/null";
48064786
src/Sema.zig+7-4
......@@ -183,6 +183,7 @@ const InternPool = @import("InternPool.zig");
183183const Alignment = InternPool.Alignment;
184184const AnalUnit = InternPool.AnalUnit;
185185const ComptimeAllocIndex = InternPool.ComptimeAllocIndex;
186const Cache = std.Build.Cache;
186187
187188pub const default_branch_quota = 1000;
188189pub const default_reference_trace_len = 2;
......@@ -5871,16 +5872,18 @@ fn zirCImport(sema: *Sema, parent_block: *Block, inst: Zir.Inst.Index) CompileEr
58715872 return sema.failWithOwnedErrorMsg(&child_block, msg);
58725873 }
58735874 const parent_mod = parent_block.ownerModule();
5875 const digest = Cache.binToHex(c_import_res.digest);
5876 const c_import_zig_path = try comp.arena.dupe(u8, "o" ++ std.fs.path.sep_str ++ digest);
58745877 const c_import_mod = Package.Module.create(comp.arena, .{
58755878 .global_cache_directory = comp.global_cache_directory,
58765879 .paths = .{
58775880 .root = .{
5878 .root_dir = Compilation.Directory.cwd(),
5879 .sub_path = std.fs.path.dirname(c_import_res.out_zig_path) orelse "",
5881 .root_dir = comp.local_cache_directory,
5882 .sub_path = c_import_zig_path,
58805883 },
5881 .root_src_path = std.fs.path.basename(c_import_res.out_zig_path),
5884 .root_src_path = "cimport.zig",
58825885 },
5883 .fully_qualified_name = c_import_res.out_zig_path,
5886 .fully_qualified_name = c_import_zig_path,
58845887 .cc_argv = parent_mod.cc_argv,
58855888 .inherited = .{},
58865889 .global = comp.config,
src/link.zig+13-9
......@@ -11,6 +11,7 @@ const wasi_libc = @import("wasi_libc.zig");
1111const Air = @import("Air.zig");
1212const Allocator = std.mem.Allocator;
1313const Cache = std.Build.Cache;
14const Path = Cache.Path;
1415const Compilation = @import("Compilation.zig");
1516const LibCInstallation = std.zig.LibCInstallation;
1617const Liveness = @import("Liveness.zig");
......@@ -56,7 +57,7 @@ pub const File = struct {
5657
5758 /// The owner of this output File.
5859 comp: *Compilation,
59 emit: Compilation.Emit,
60 emit: Path,
6061
6162 file: ?fs.File,
6263 /// When linking with LLD, this linker code will output an object file only at
......@@ -189,7 +190,7 @@ pub const File = struct {
189190 pub fn open(
190191 arena: Allocator,
191192 comp: *Compilation,
192 emit: Compilation.Emit,
193 emit: Path,
193194 options: OpenOptions,
194195 ) !*File {
195196 switch (Tag.fromObjectFormat(comp.root_mod.resolved_target.result.ofmt)) {
......@@ -204,7 +205,7 @@ pub const File = struct {
204205 pub fn createEmpty(
205206 arena: Allocator,
206207 comp: *Compilation,
207 emit: Compilation.Emit,
208 emit: Path,
208209 options: OpenOptions,
209210 ) !*File {
210211 switch (Tag.fromObjectFormat(comp.root_mod.resolved_target.result.ofmt)) {
......@@ -243,8 +244,8 @@ pub const File = struct {
243244 emit.sub_path, std.crypto.random.int(u32),
244245 });
245246 defer gpa.free(tmp_sub_path);
246 try emit.directory.handle.copyFile(emit.sub_path, emit.directory.handle, tmp_sub_path, .{});
247 try emit.directory.handle.rename(tmp_sub_path, emit.sub_path);
247 try emit.root_dir.handle.copyFile(emit.sub_path, emit.root_dir.handle, tmp_sub_path, .{});
248 try emit.root_dir.handle.rename(tmp_sub_path, emit.sub_path);
248249 switch (builtin.os.tag) {
249250 .linux => std.posix.ptrace(std.os.linux.PTRACE.ATTACH, pid, 0, 0) catch |err| {
250251 log.warn("ptrace failure: {s}", .{@errorName(err)});
......@@ -260,7 +261,7 @@ pub const File = struct {
260261 const use_lld = build_options.have_llvm and comp.config.use_lld;
261262 const output_mode = comp.config.output_mode;
262263 const link_mode = comp.config.link_mode;
263 base.file = try emit.directory.handle.createFile(emit.sub_path, .{
264 base.file = try emit.root_dir.handle.createFile(emit.sub_path, .{
264265 .truncate = false,
265266 .read = true,
266267 .mode = determineMode(use_lld, output_mode, link_mode),
......@@ -603,7 +604,7 @@ pub const File = struct {
603604 // Until then, we do `lld -r -o output.o input.o` even though the output is the same
604605 // as the input. For the preprocessing case (`zig cc -E -o foo`) we copy the file
605606 // to the final location. See also the corresponding TODO in Coff linking.
606 const full_out_path = try emit.directory.join(gpa, &[_][]const u8{emit.sub_path});
607 const full_out_path = try emit.root_dir.join(gpa, &[_][]const u8{emit.sub_path});
607608 defer gpa.free(full_out_path);
608609 assert(comp.c_object_table.count() == 1);
609610 const the_key = comp.c_object_table.keys()[0];
......@@ -751,7 +752,7 @@ pub const File = struct {
751752 const comp = base.comp;
752753 const gpa = comp.gpa;
753754
754 const directory = base.emit.directory; // Just an alias to make it shorter to type.
755 const directory = base.emit.root_dir; // Just an alias to make it shorter to type.
755756 const full_out_path = try directory.join(arena, &[_][]const u8{base.emit.sub_path});
756757 const full_out_path_z = try arena.dupeZ(u8, full_out_path);
757758 const opt_zcu = comp.module;
......@@ -1029,7 +1030,10 @@ pub const File = struct {
10291030 llvm_object: LlvmObject.Ptr,
10301031 prog_node: std.Progress.Node,
10311032 ) !void {
1032 return base.comp.emitLlvmObject(arena, base.emit, .{
1033 return base.comp.emitLlvmObject(arena, .{
1034 .root_dir = base.emit.root_dir,
1035 .sub_path = std.fs.path.dirname(base.emit.sub_path) orelse "",
1036 }, .{
10331037 .directory = null,
10341038 .basename = base.zcu_object_sub_path.?,
10351039 }, llvm_object, prog_node);
src/link/C.zig+4-3
......@@ -3,6 +3,7 @@ const mem = std.mem;
33const assert = std.debug.assert;
44const Allocator = std.mem.Allocator;
55const fs = std.fs;
6const Path = std.Build.Cache.Path;
67
78const C = @This();
89const build_options = @import("build_options");
......@@ -104,7 +105,7 @@ pub fn addString(this: *C, s: []const u8) Allocator.Error!String {
104105pub fn open(
105106 arena: Allocator,
106107 comp: *Compilation,
107 emit: Compilation.Emit,
108 emit: Path,
108109 options: link.File.OpenOptions,
109110) !*C {
110111 return createEmpty(arena, comp, emit, options);
......@@ -113,7 +114,7 @@ pub fn open(
113114pub fn createEmpty(
114115 arena: Allocator,
115116 comp: *Compilation,
116 emit: Compilation.Emit,
117 emit: Path,
117118 options: link.File.OpenOptions,
118119) !*C {
119120 const target = comp.root_mod.resolved_target.result;
......@@ -127,7 +128,7 @@ pub fn createEmpty(
127128 assert(!use_lld);
128129 assert(!use_llvm);
129130
130 const file = try emit.directory.handle.createFile(emit.sub_path, .{
131 const file = try emit.root_dir.handle.createFile(emit.sub_path, .{
131132 // Truncation is done on `flush`.
132133 .truncate = false,
133134 });
src/link/Coff.zig+4-3
......@@ -219,7 +219,7 @@ pub const min_text_capacity = padToIdeal(minimum_text_block_size);
219219pub fn createEmpty(
220220 arena: Allocator,
221221 comp: *Compilation,
222 emit: Compilation.Emit,
222 emit: Path,
223223 options: link.File.OpenOptions,
224224) !*Coff {
225225 const target = comp.root_mod.resolved_target.result;
......@@ -315,7 +315,7 @@ pub fn createEmpty(
315315 // If using LLD to link, this code should produce an object file so that it
316316 // can be passed to LLD.
317317 const sub_path = if (use_lld) zcu_object_sub_path.? else emit.sub_path;
318 self.base.file = try emit.directory.handle.createFile(sub_path, .{
318 self.base.file = try emit.root_dir.handle.createFile(sub_path, .{
319319 .truncate = true,
320320 .read = true,
321321 .mode = link.File.determineMode(use_lld, output_mode, link_mode),
......@@ -416,7 +416,7 @@ pub fn createEmpty(
416416pub fn open(
417417 arena: Allocator,
418418 comp: *Compilation,
419 emit: Compilation.Emit,
419 emit: Path,
420420 options: link.File.OpenOptions,
421421) !*Coff {
422422 // TODO: restore saved linker state, don't truncate the file, and
......@@ -2714,6 +2714,7 @@ const math = std.math;
27142714const mem = std.mem;
27152715
27162716const Allocator = std.mem.Allocator;
2717const Path = std.Build.Cache.Path;
27172718
27182719const codegen = @import("../codegen.zig");
27192720const link = @import("../link.zig");
src/link/Coff/lld.zig+2-2
......@@ -27,7 +27,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
2727 const comp = self.base.comp;
2828 const gpa = comp.gpa;
2929
30 const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
30 const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
3131 const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
3232
3333 // If there is no Zig code to compile, then we should skip flushing the output file because it
......@@ -248,7 +248,7 @@ pub fn linkWithLLD(self: *Coff, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
248248 try argv.append(try allocPrint(arena, "-OUT:{s}", .{full_out_path}));
249249
250250 if (comp.implib_emit) |emit| {
251 const implib_out_path = try emit.directory.join(arena, &[_][]const u8{emit.sub_path});
251 const implib_out_path = try emit.root_dir.join(arena, &[_][]const u8{emit.sub_path});
252252 try argv.append(try allocPrint(arena, "-IMPLIB:{s}", .{implib_out_path}));
253253 }
254254
src/link/Elf.zig+7-6
......@@ -204,7 +204,7 @@ pub const SortSection = enum { name, alignment };
204204pub fn createEmpty(
205205 arena: Allocator,
206206 comp: *Compilation,
207 emit: Compilation.Emit,
207 emit: Path,
208208 options: link.File.OpenOptions,
209209) !*Elf {
210210 const target = comp.root_mod.resolved_target.result;
......@@ -321,7 +321,7 @@ pub fn createEmpty(
321321 // If using LLD to link, this code should produce an object file so that it
322322 // can be passed to LLD.
323323 const sub_path = if (use_lld) zcu_object_sub_path.? else emit.sub_path;
324 self.base.file = try emit.directory.handle.createFile(sub_path, .{
324 self.base.file = try emit.root_dir.handle.createFile(sub_path, .{
325325 .truncate = true,
326326 .read = true,
327327 .mode = link.File.determineMode(use_lld, output_mode, link_mode),
......@@ -401,7 +401,7 @@ pub fn createEmpty(
401401pub fn open(
402402 arena: Allocator,
403403 comp: *Compilation,
404 emit: Compilation.Emit,
404 emit: Path,
405405 options: link.File.OpenOptions,
406406) !*Elf {
407407 // TODO: restore saved linker state, don't truncate the file, and
......@@ -999,7 +999,7 @@ pub fn flushModule(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_nod
999999
10001000 const target = comp.root_mod.resolved_target.result;
10011001 const link_mode = comp.config.link_mode;
1002 const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
1002 const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
10031003 const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
10041004 const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
10051005 if (fs.path.dirname(full_out_path)) |dirname| {
......@@ -1356,7 +1356,7 @@ fn dumpArgv(self: *Elf, comp: *Compilation) !void {
13561356
13571357 const target = self.base.comp.root_mod.resolved_target.result;
13581358 const link_mode = self.base.comp.config.link_mode;
1359 const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
1359 const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
13601360 const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
13611361 const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
13621362 if (fs.path.dirname(full_out_path)) |dirname| {
......@@ -2054,7 +2054,7 @@ fn linkWithLLD(self: *Elf, arena: Allocator, tid: Zcu.PerThread.Id, prog_node: s
20542054 const comp = self.base.comp;
20552055 const gpa = comp.gpa;
20562056
2057 const directory = self.base.emit.directory; // Just an alias to make it shorter to type.
2057 const directory = self.base.emit.root_dir; // Just an alias to make it shorter to type.
20582058 const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
20592059
20602060 // If there is no Zig code to compile, then we should skip flushing the output file because it
......@@ -6016,6 +6016,7 @@ const Allocator = std.mem.Allocator;
60166016const Archive = @import("Elf/Archive.zig");
60176017pub const Atom = @import("Elf/Atom.zig");
60186018const Cache = std.Build.Cache;
6019const Path = Cache.Path;
60196020const Compilation = @import("../Compilation.zig");
60206021const ComdatGroupSection = synthetic_sections.ComdatGroupSection;
60216022const CopyRelSection = synthetic_sections.CopyRelSection;
src/link/MachO.zig+9-8
......@@ -156,7 +156,7 @@ pub fn hashAddFrameworks(man: *Cache.Manifest, hm: []const Framework) !void {
156156pub fn createEmpty(
157157 arena: Allocator,
158158 comp: *Compilation,
159 emit: Compilation.Emit,
159 emit: Path,
160160 options: link.File.OpenOptions,
161161) !*MachO {
162162 const target = comp.root_mod.resolved_target.result;
......@@ -221,7 +221,7 @@ pub fn createEmpty(
221221 }
222222 errdefer self.base.destroy();
223223
224 self.base.file = try emit.directory.handle.createFile(emit.sub_path, .{
224 self.base.file = try emit.root_dir.handle.createFile(emit.sub_path, .{
225225 .truncate = true,
226226 .read = true,
227227 .mode = link.File.determineMode(false, output_mode, link_mode),
......@@ -260,7 +260,7 @@ pub fn createEmpty(
260260pub fn open(
261261 arena: Allocator,
262262 comp: *Compilation,
263 emit: Compilation.Emit,
263 emit: Path,
264264 options: link.File.OpenOptions,
265265) !*MachO {
266266 // TODO: restore saved linker state, don't truncate the file, and
......@@ -353,7 +353,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
353353 const sub_prog_node = prog_node.start("MachO Flush", 0);
354354 defer sub_prog_node.end();
355355
356 const directory = self.base.emit.directory;
356 const directory = self.base.emit.root_dir;
357357 const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
358358 const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
359359 if (fs.path.dirname(full_out_path)) |dirname| {
......@@ -586,7 +586,7 @@ pub fn flushModule(self: *MachO, arena: Allocator, tid: Zcu.PerThread.Id, prog_n
586586 if (codesig) |*csig| {
587587 try self.writeCodeSignature(csig); // code signing always comes last
588588 const emit = self.base.emit;
589 try invalidateKernelCache(emit.directory.handle, emit.sub_path);
589 try invalidateKernelCache(emit.root_dir.handle, emit.sub_path);
590590 }
591591}
592592
......@@ -597,7 +597,7 @@ fn dumpArgv(self: *MachO, comp: *Compilation) !void {
597597 defer arena_allocator.deinit();
598598 const arena = arena_allocator.allocator();
599599
600 const directory = self.base.emit.directory;
600 const directory = self.base.emit.root_dir;
601601 const full_out_path = try directory.join(arena, &[_][]const u8{self.base.emit.sub_path});
602602 const module_obj_path: ?[]const u8 = if (self.base.zcu_object_sub_path) |path| blk: {
603603 if (fs.path.dirname(full_out_path)) |dirname| {
......@@ -3199,7 +3199,7 @@ fn copyRangeAllZeroOut(self: *MachO, old_offset: u64, new_offset: u64, size: u64
31993199}
32003200
32013201const InitMetadataOptions = struct {
3202 emit: Compilation.Emit,
3202 emit: Path,
32033203 zo: *ZigObject,
32043204 symbol_count_hint: u64,
32053205 program_code_size_hint: u64,
......@@ -3271,7 +3271,7 @@ fn initMetadata(self: *MachO, options: InitMetadataOptions) !void {
32713271 );
32723272 defer gpa.free(d_sym_path);
32733273
3274 var d_sym_bundle = try options.emit.directory.handle.makeOpenPath(d_sym_path, .{});
3274 var d_sym_bundle = try options.emit.root_dir.handle.makeOpenPath(d_sym_path, .{});
32753275 defer d_sym_bundle.close();
32763276
32773277 const d_sym_file = try d_sym_bundle.createFile(options.emit.sub_path, .{
......@@ -4603,6 +4603,7 @@ pub const Atom = @import("MachO/Atom.zig");
46034603const AtomicBool = std.atomic.Value(bool);
46044604const Bind = bind.Bind;
46054605const Cache = std.Build.Cache;
4606const Path = Cache.Path;
46064607const CodeSignature = @import("MachO/CodeSignature.zig");
46074608const Compilation = @import("../Compilation.zig");
46084609const DataInCode = synthetic.DataInCode;
src/link/MachO/load_commands.zig+2-2
......@@ -53,7 +53,7 @@ pub fn calcLoadCommandsSize(macho_file: *MachO, assume_max_path_len: bool) !u32
5353 if (macho_file.base.isDynLib()) {
5454 const emit = macho_file.base.emit;
5555 const install_name = macho_file.install_name orelse
56 try emit.directory.join(gpa, &.{emit.sub_path});
56 try emit.root_dir.join(gpa, &.{emit.sub_path});
5757 defer if (macho_file.install_name == null) gpa.free(install_name);
5858 sizeofcmds += calcInstallNameLen(
5959 @sizeOf(macho.dylib_command),
......@@ -237,7 +237,7 @@ pub fn writeDylibIdLC(macho_file: *MachO, writer: anytype) !void {
237237 assert(comp.config.output_mode == .Lib and comp.config.link_mode == .dynamic);
238238 const emit = macho_file.base.emit;
239239 const install_name = macho_file.install_name orelse
240 try emit.directory.join(gpa, &.{emit.sub_path});
240 try emit.root_dir.join(gpa, &.{emit.sub_path});
241241 defer if (macho_file.install_name == null) gpa.free(install_name);
242242 const curr = comp.version orelse std.SemanticVersion{
243243 .major = 1,
src/link/NvPtx.zig+3-2
......@@ -11,6 +11,7 @@ const builtin = @import("builtin");
1111const Allocator = std.mem.Allocator;
1212const assert = std.debug.assert;
1313const log = std.log.scoped(.link);
14const Path = std.Build.Cache.Path;
1415
1516const Zcu = @import("../Zcu.zig");
1617const InternPool = @import("../InternPool.zig");
......@@ -28,7 +29,7 @@ llvm_object: LlvmObject.Ptr,
2829pub fn createEmpty(
2930 arena: Allocator,
3031 comp: *Compilation,
31 emit: Compilation.Emit,
32 emit: Path,
3233 options: link.File.OpenOptions,
3334) !*NvPtx {
3435 const target = comp.root_mod.resolved_target.result;
......@@ -70,7 +71,7 @@ pub fn createEmpty(
7071pub fn open(
7172 arena: Allocator,
7273 comp: *Compilation,
73 emit: Compilation.Emit,
74 emit: Path,
7475 options: link.File.OpenOptions,
7576) !*NvPtx {
7677 const target = comp.root_mod.resolved_target.result;
src/link/Plan9.zig+4-3
......@@ -23,6 +23,7 @@ const mem = std.mem;
2323const Allocator = std.mem.Allocator;
2424const log = std.log.scoped(.link);
2525const assert = std.debug.assert;
26const Path = std.Build.Cache.Path;
2627
2728base: link.File,
2829sixtyfour_bit: bool,
......@@ -275,7 +276,7 @@ pub fn defaultBaseAddrs(arch: std.Target.Cpu.Arch) Bases {
275276pub fn createEmpty(
276277 arena: Allocator,
277278 comp: *Compilation,
278 emit: Compilation.Emit,
279 emit: Path,
279280 options: link.File.OpenOptions,
280281) !*Plan9 {
281282 const target = comp.root_mod.resolved_target.result;
......@@ -1199,7 +1200,7 @@ pub fn deinit(self: *Plan9) void {
11991200pub fn open(
12001201 arena: Allocator,
12011202 comp: *Compilation,
1202 emit: Compilation.Emit,
1203 emit: Path,
12031204 options: link.File.OpenOptions,
12041205) !*Plan9 {
12051206 const target = comp.root_mod.resolved_target.result;
......@@ -1213,7 +1214,7 @@ pub fn open(
12131214 const self = try createEmpty(arena, comp, emit, options);
12141215 errdefer self.base.destroy();
12151216
1216 const file = try emit.directory.handle.createFile(emit.sub_path, .{
1217 const file = try emit.root_dir.handle.createFile(emit.sub_path, .{
12171218 .read = true,
12181219 .mode = link.File.determineMode(
12191220 use_lld,
src/link/SpirV.zig+4-3
......@@ -26,6 +26,7 @@ const std = @import("std");
2626const Allocator = std.mem.Allocator;
2727const assert = std.debug.assert;
2828const log = std.log.scoped(.link);
29const Path = std.Build.Cache.Path;
2930
3031const Zcu = @import("../Zcu.zig");
3132const InternPool = @import("../InternPool.zig");
......@@ -54,7 +55,7 @@ object: codegen.Object,
5455pub fn createEmpty(
5556 arena: Allocator,
5657 comp: *Compilation,
57 emit: Compilation.Emit,
58 emit: Path,
5859 options: link.File.OpenOptions,
5960) !*SpirV {
6061 const gpa = comp.gpa;
......@@ -95,7 +96,7 @@ pub fn createEmpty(
9596pub fn open(
9697 arena: Allocator,
9798 comp: *Compilation,
98 emit: Compilation.Emit,
99 emit: Path,
99100 options: link.File.OpenOptions,
100101) !*SpirV {
101102 const target = comp.root_mod.resolved_target.result;
......@@ -110,7 +111,7 @@ pub fn open(
110111 errdefer spirv.base.destroy();
111112
112113 // TODO: read the file and keep valid parts instead of truncating
113 const file = try emit.directory.handle.createFile(emit.sub_path, .{
114 const file = try emit.root_dir.handle.createFile(emit.sub_path, .{
114115 .truncate = true,
115116 .read = true,
116117 });
src/link/Wasm.zig+6-5
......@@ -22,6 +22,7 @@ const Air = @import("../Air.zig");
2222const Allocator = std.mem.Allocator;
2323const Archive = @import("Wasm/Archive.zig");
2424const Cache = std.Build.Cache;
25const Path = Cache.Path;
2526const CodeGen = @import("../arch/wasm/CodeGen.zig");
2627const Compilation = @import("../Compilation.zig");
2728const Dwarf = @import("Dwarf.zig");
......@@ -346,7 +347,7 @@ pub const StringTable = struct {
346347pub fn open(
347348 arena: Allocator,
348349 comp: *Compilation,
349 emit: Compilation.Emit,
350 emit: Path,
350351 options: link.File.OpenOptions,
351352) !*Wasm {
352353 // TODO: restore saved linker state, don't truncate the file, and
......@@ -357,7 +358,7 @@ pub fn open(
357358pub fn createEmpty(
358359 arena: Allocator,
359360 comp: *Compilation,
360 emit: Compilation.Emit,
361 emit: Path,
361362 options: link.File.OpenOptions,
362363) !*Wasm {
363364 const gpa = comp.gpa;
......@@ -430,7 +431,7 @@ pub fn createEmpty(
430431 // can be passed to LLD.
431432 const sub_path = if (use_lld) zcu_object_sub_path.? else emit.sub_path;
432433
433 wasm.base.file = try emit.directory.handle.createFile(sub_path, .{
434 wasm.base.file = try emit.root_dir.handle.createFile(sub_path, .{
434435 .truncate = true,
435436 .read = true,
436437 .mode = if (fs.has_executable_bit)
......@@ -2496,7 +2497,7 @@ pub fn flushModule(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_no
24962497 const sub_prog_node = prog_node.start("Wasm Flush", 0);
24972498 defer sub_prog_node.end();
24982499
2499 const directory = wasm.base.emit.directory; // Just an alias to make it shorter to type.
2500 const directory = wasm.base.emit.root_dir; // Just an alias to make it shorter to type.
25002501 const full_out_path = try directory.join(arena, &[_][]const u8{wasm.base.emit.sub_path});
25012502 const module_obj_path: ?[]const u8 = if (wasm.base.zcu_object_sub_path) |path| blk: {
25022503 if (fs.path.dirname(full_out_path)) |dirname| {
......@@ -3346,7 +3347,7 @@ fn linkWithLLD(wasm: *Wasm, arena: Allocator, tid: Zcu.PerThread.Id, prog_node:
33463347
33473348 const gpa = comp.gpa;
33483349
3349 const directory = wasm.base.emit.directory; // Just an alias to make it shorter to type.
3350 const directory = wasm.base.emit.root_dir; // Just an alias to make it shorter to type.
33503351 const full_out_path = try directory.join(arena, &[_][]const u8{wasm.base.emit.sub_path});
33513352
33523353 // If there is no Zig code to compile, then we should skip flushing the output file because it
src/main.zig+18-68
......@@ -3519,7 +3519,7 @@ fn buildOutputType(
35193519 if (test_exec_args.items.len == 0 and target.ofmt == .c) default_exec_args: {
35203520 // Default to using `zig run` to execute the produced .c code from `zig test`.
35213521 const c_code_loc = emit_bin_loc orelse break :default_exec_args;
3522 const c_code_directory = c_code_loc.directory orelse comp.bin_file.?.emit.directory;
3522 const c_code_directory = c_code_loc.directory orelse comp.bin_file.?.emit.root_dir;
35233523 const c_code_path = try fs.path.join(arena, &[_][]const u8{
35243524 c_code_directory.path orelse ".", c_code_loc.basename,
35253525 });
......@@ -4142,7 +4142,7 @@ fn serve(
41424142 if (output.errors.errorMessageCount() != 0) {
41434143 try server.serveErrorBundle(output.errors);
41444144 } else {
4145 try server.serveEmitBinPath(output.out_zig_path, .{
4145 try server.serveEmitDigest(&output.digest, .{
41464146 .flags = .{ .cache_hit = output.cache_hit },
41474147 });
41484148 }
......@@ -4229,62 +4229,10 @@ fn serveUpdateResults(s: *Server, comp: *Compilation) !void {
42294229 return;
42304230 }
42314231
4232 // This logic is counter-intuitive because the protocol accounts for each
4233 // emitted artifact possibly being in a different location, which correctly
4234 // matches the behavior of the compiler, however, the build system
4235 // currently always passes flags that makes all build artifacts output to
4236 // the same local cache directory, and relies on them all being in the same
4237 // directory.
4238 //
4239 // So, until the build system and protocol are changed to reflect this,
4240 // this logic must ensure that emit_bin_path is emitted for at least one
4241 // thing, if there are any artifacts.
4242
4243 switch (comp.cache_use) {
4244 .incremental => if (comp.bin_file) |lf| {
4245 const full_path = try lf.emit.directory.join(gpa, &.{lf.emit.sub_path});
4246 defer gpa.free(full_path);
4247 try s.serveEmitBinPath(full_path, .{
4248 .flags = .{ .cache_hit = comp.last_update_was_cache_hit },
4249 });
4250 return;
4251 },
4252 .whole => |whole| if (whole.bin_sub_path) |sub_path| {
4253 const full_path = try comp.local_cache_directory.join(gpa, &.{sub_path});
4254 defer gpa.free(full_path);
4255 try s.serveEmitBinPath(full_path, .{
4256 .flags = .{ .cache_hit = comp.last_update_was_cache_hit },
4257 });
4258 return;
4259 },
4260 }
4261
4262 for ([_]?Compilation.Emit{
4263 comp.docs_emit,
4264 comp.implib_emit,
4265 }) |opt_emit| {
4266 const emit = opt_emit orelse continue;
4267 const full_path = try emit.directory.join(gpa, &.{emit.sub_path});
4268 defer gpa.free(full_path);
4269 try s.serveEmitBinPath(full_path, .{
4232 if (comp.digest) |digest| {
4233 try s.serveEmitDigest(&digest, .{
42704234 .flags = .{ .cache_hit = comp.last_update_was_cache_hit },
42714235 });
4272 return;
4273 }
4274
4275 for ([_]?Compilation.EmitLoc{
4276 comp.emit_asm,
4277 comp.emit_llvm_ir,
4278 comp.emit_llvm_bc,
4279 }) |opt_emit_loc| {
4280 const emit_loc = opt_emit_loc orelse continue;
4281 const directory = emit_loc.directory orelse continue;
4282 const full_path = try directory.join(gpa, &.{emit_loc.basename});
4283 defer gpa.free(full_path);
4284 try s.serveEmitBinPath(full_path, .{
4285 .flags = .{ .cache_hit = comp.last_update_was_cache_hit },
4286 });
4287 return;
42884236 }
42894237
42904238 // Serve empty error bundle to indicate the update is done.
......@@ -4308,7 +4256,7 @@ fn runOrTest(
43084256 // A naive `directory.join` here will indeed get the correct path to the binary,
43094257 // however, in the case of cwd, we actually want `./foo` so that the path can be executed.
43104258 const exe_path = try fs.path.join(arena, &[_][]const u8{
4311 lf.emit.directory.path orelse ".", lf.emit.sub_path,
4259 lf.emit.root_dir.path orelse ".", lf.emit.sub_path,
43124260 });
43134261
43144262 var argv = std.ArrayList([]const u8).init(gpa);
......@@ -4420,7 +4368,7 @@ fn runOrTestHotSwap(
44204368 // tmp zig-cache and use it to spawn the child process. This way we are free to update
44214369 // the binary with each requested hot update.
44224370 .windows => blk: {
4423 try lf.emit.directory.handle.copyFile(lf.emit.sub_path, comp.local_cache_directory.handle, lf.emit.sub_path, .{});
4371 try lf.emit.root_dir.handle.copyFile(lf.emit.sub_path, comp.local_cache_directory.handle, lf.emit.sub_path, .{});
44244372 break :blk try fs.path.join(gpa, &[_][]const u8{
44254373 comp.local_cache_directory.path orelse ".", lf.emit.sub_path,
44264374 });
......@@ -4429,7 +4377,7 @@ fn runOrTestHotSwap(
44294377 // A naive `directory.join` here will indeed get the correct path to the binary,
44304378 // however, in the case of cwd, we actually want `./foo` so that the path can be executed.
44314379 else => try fs.path.join(gpa, &[_][]const u8{
4432 lf.emit.directory.path orelse ".", lf.emit.sub_path,
4380 lf.emit.root_dir.path orelse ".", lf.emit.sub_path,
44334381 }),
44344382 };
44354383 defer gpa.free(exe_path);
......@@ -4539,9 +4487,11 @@ fn cmdTranslateC(
45394487 };
45404488
45414489 if (fancy_output) |p| p.cache_hit = true;
4542 const digest = if (try man.hit()) digest: {
4490 const bin_digest, const hex_digest = if (try man.hit()) digest: {
45434491 if (file_system_inputs) |buf| try man.populateFileSystemInputs(buf);
4544 break :digest man.final();
4492 const bin_digest = man.finalBin();
4493 const hex_digest = Cache.binToHex(bin_digest);
4494 break :digest .{ bin_digest, hex_digest };
45454495 } else digest: {
45464496 if (fancy_output) |p| p.cache_hit = false;
45474497 var argv = std.ArrayList([]const u8).init(arena);
......@@ -4639,8 +4589,10 @@ fn cmdTranslateC(
46394589 };
46404590 }
46414591
4642 const digest = man.final();
4643 const o_sub_path = try fs.path.join(arena, &[_][]const u8{ "o", &digest });
4592 const bin_digest = man.finalBin();
4593 const hex_digest = Cache.binToHex(bin_digest);
4594
4595 const o_sub_path = try fs.path.join(arena, &[_][]const u8{ "o", &hex_digest });
46444596
46454597 var o_dir = try comp.local_cache_directory.handle.makeOpenPath(o_sub_path, .{});
46464598 defer o_dir.close();
......@@ -4656,16 +4608,14 @@ fn cmdTranslateC(
46564608
46574609 if (file_system_inputs) |buf| try man.populateFileSystemInputs(buf);
46584610
4659 break :digest digest;
4611 break :digest .{ bin_digest, hex_digest };
46604612 };
46614613
46624614 if (fancy_output) |p| {
4663 p.out_zig_path = try comp.local_cache_directory.join(comp.gpa, &[_][]const u8{
4664 "o", &digest, translated_zig_basename,
4665 });
4615 p.digest = bin_digest;
46664616 p.errors = std.zig.ErrorBundle.empty;
46674617 } else {
4668 const out_zig_path = try fs.path.join(arena, &[_][]const u8{ "o", &digest, translated_zig_basename });
4618 const out_zig_path = try fs.path.join(arena, &[_][]const u8{ "o", &hex_digest, translated_zig_basename });
46694619 const zig_file = comp.local_cache_directory.handle.openFile(out_zig_path, .{}) catch |err| {
46704620 const path = comp.local_cache_directory.path orelse ".";
46714621 fatal("unable to open cached translated zig file '{s}{s}{s}': {s}", .{ path, fs.path.sep_str, out_zig_path, @errorName(err) });
test/standalone/build.zig.zon+9-8
......@@ -51,14 +51,15 @@
5151 .install_raw_hex = .{
5252 .path = "install_raw_hex",
5353 },
54 // https://github.com/ziglang/zig/issues/17484
55 //.emit_asm_and_bin = .{
56 // .path = "emit_asm_and_bin",
57 //},
58 // https://github.com/ziglang/zig/issues/17484
59 //.issue_12588 = .{
60 // .path = "issue_12588",
61 //},
54 .emit_asm_and_bin = .{
55 .path = "emit_asm_and_bin",
56 },
57 .emit_llvm_no_bin = .{
58 .path = "emit_llvm_no_bin",
59 },
60 .emit_asm_no_bin = .{
61 .path = "emit_asm_no_bin",
62 },
6263 .child_process = .{
6364 .path = "child_process",
6465 },
test/standalone/emit_asm_no_bin/build.zig created+19
......@@ -0,0 +1,19 @@
1const std = @import("std");
2
3pub fn build(b: *std.Build) void {
4 const test_step = b.step("test", "Test it");
5 b.default_step = test_step;
6
7 const optimize: std.builtin.OptimizeMode = .Debug;
8
9 const obj = b.addObject(.{
10 .name = "main",
11 .root_source_file = b.path("main.zig"),
12 .optimize = optimize,
13 .target = b.graph.host,
14 });
15 _ = obj.getEmittedAsm();
16 b.default_step.dependOn(&obj.step);
17
18 test_step.dependOn(&obj.step);
19}
test/standalone/emit_asm_no_bin/main.zig created+1
......@@ -0,0 +1 @@
1pub fn main() void {}
test/standalone/emit_llvm_no_bin/build.zig created+20
......@@ -0,0 +1,20 @@
1const std = @import("std");
2
3pub fn build(b: *std.Build) void {
4 const test_step = b.step("test", "Test it");
5 b.default_step = test_step;
6
7 const optimize: std.builtin.OptimizeMode = .Debug;
8
9 const obj = b.addObject(.{
10 .name = "main",
11 .root_source_file = b.path("main.zig"),
12 .optimize = optimize,
13 .target = b.graph.host,
14 });
15 _ = obj.getEmittedLlvmIr();
16 _ = obj.getEmittedLlvmBc();
17 b.default_step.dependOn(&obj.step);
18
19 test_step.dependOn(&obj.step);
20}
test/standalone/emit_llvm_no_bin/main.zig created+6
......@@ -0,0 +1,6 @@
1const std = @import("std");
2
3export fn strFromFloatHelp(float: f64) void {
4 var buf: [400]u8 = undefined;
5 _ = std.fmt.bufPrint(&buf, "{d}", .{float}) catch unreachable;
6}
test/standalone/issue_12588/build.zig deleted-20
......@@ -1,20 +0,0 @@
1const std = @import("std");
2
3pub fn build(b: *std.Build) void {
4 const test_step = b.step("test", "Test it");
5 b.default_step = test_step;
6
7 const optimize: std.builtin.OptimizeMode = .Debug;
8
9 const obj = b.addObject(.{
10 .name = "main",
11 .root_source_file = b.path("main.zig"),
12 .optimize = optimize,
13 .target = b.graph.host,
14 });
15 _ = obj.getEmittedLlvmIr();
16 _ = obj.getEmittedLlvmBc();
17 b.default_step.dependOn(&obj.step);
18
19 test_step.dependOn(&obj.step);
20}
test/standalone/issue_12588/main.zig deleted-6
......@@ -1,6 +0,0 @@
1const std = @import("std");
2
3export fn strFromFloatHelp(float: f64) void {
4 var buf: [400]u8 = undefined;
5 _ = std.fmt.bufPrint(&buf, "{d}", .{float}) catch unreachable;
6}
tools/incr-check.zig+33-10
......@@ -1,6 +1,7 @@
11const std = @import("std");
22const fatal = std.process.fatal;
33const Allocator = std.mem.Allocator;
4const Cache = std.Build.Cache;
45
56const usage = "usage: incr-check <zig binary path> <input file> [--zig-lib-dir lib] [--debug-zcu] [--emit none|bin|c] [--zig-cc-binary /path/to/zig]";
67
......@@ -233,30 +234,52 @@ const Eval = struct {
233234 fatal("error_bundle included unexpected stderr:\n{s}", .{stderr_data});
234235 }
235236 }
236 if (result_error_bundle.errorMessageCount() == 0) {
237 // Empty bundle indicates successful update in a `-fno-emit-bin` build.
238 try eval.checkSuccessOutcome(update, null, prog_node);
239 } else {
237 if (result_error_bundle.errorMessageCount() != 0) {
240238 try eval.checkErrorOutcome(update, result_error_bundle);
241239 }
242240 // This message indicates the end of the update.
243241 stdout.discard(body.len);
244242 return;
245243 },
246 .emit_bin_path => {
247 const EbpHdr = std.zig.Server.Message.EmitBinPath;
244 .emit_digest => {
245 const EbpHdr = std.zig.Server.Message.EmitDigest;
248246 const ebp_hdr = @as(*align(1) const EbpHdr, @ptrCast(body));
249247 _ = ebp_hdr;
250 const result_binary = try arena.dupe(u8, body[@sizeOf(EbpHdr)..]);
251248 if (stderr.readableLength() > 0) {
252249 const stderr_data = try stderr.toOwnedSlice();
253250 if (eval.allow_stderr) {
254 std.log.info("emit_bin_path included stderr:\n{s}", .{stderr_data});
251 std.log.info("emit_digest included stderr:\n{s}", .{stderr_data});
255252 } else {
256 fatal("emit_bin_path included unexpected stderr:\n{s}", .{stderr_data});
253 fatal("emit_digest included unexpected stderr:\n{s}", .{stderr_data});
257254 }
258255 }
259 try eval.checkSuccessOutcome(update, result_binary, prog_node);
256
257 if (eval.emit == .none) {
258 try eval.checkSuccessOutcome(update, null, prog_node);
259 // This message indicates the end of the update.
260 stdout.discard(body.len);
261 return;
262 }
263
264 const digest = body[@sizeOf(EbpHdr)..][0..Cache.bin_digest_len];
265 const result_dir = ".local-cache" ++ std.fs.path.sep_str ++ "o" ++ std.fs.path.sep_str ++ Cache.binToHex(digest.*);
266
267 const name = std.fs.path.stem(std.fs.path.basename(eval.case.root_source_file));
268 const bin_name = try std.zig.binNameAlloc(arena, .{
269 .root_name = name,
270 .target = try std.zig.system.resolveTargetQuery(try std.Build.parseTargetQuery(.{
271 .arch_os_abi = eval.case.target_query,
272 .object_format = switch (eval.emit) {
273 .none => unreachable,
274 .bin => null,
275 .c => "c",
276 },
277 })),
278 .output_mode = .Exe,
279 });
280 const bin_path = try std.fs.path.join(arena, &.{ result_dir, bin_name });
281
282 try eval.checkSuccessOutcome(update, bin_path, prog_node);
260283 // This message indicates the end of the update.
261284 stdout.discard(body.len);
262285 return;