Commit 3ec6d655dd61ed5fd0a0d33e33e58b12d5b658f5 | zig

author	Techatrix <techatrix@mailbox.org> 2026-08-12 20:36:27+02:00
committer	Andrew Kelley <andrew@ziglang.org> 2026-08-13 02:03:22+02:00
log	3ec6d655dd61ed5fd0a0d33e33e58b12d5b658f5
tree	0c2dc079a668ff74c0816db732a7d9716840e211
parent	8e48a5c524f970c4630725e2efe69243d8d79fde

fix compilation errors when building compiler for wasm32-wasi

4 files changed, 84 insertions(+), 55 deletions(-)

src/link.zig+1-1

...	@@ -1337,7 +1337,7 @@ pub const File = struct {	...	@@ -1337,7 +1337,7 @@ pub const File = struct {
1337	// with 0o755 permissions, but it works appropriately if the system is configured	1337	// with 0o755 permissions, but it works appropriately if the system is configured
1338	// more leniently. As another data point, C's fopen seems to open files with the	1338	// more leniently. As another data point, C's fopen seems to open files with the
1339	// 666 mode.	1339	// 666 mode.
1340	const executable_mode: Io.File.Permissions = if (builtin.target.os.tag == .windows)	1340	const executable_mode: Io.File.Permissions = if (builtin.target.os.tag == .windows or std.posix.mode_t == u0)
1341	.default_file	1341	.default_file
1342	else	1342	else
1343	.fromMode(0o777);	1343	.fromMode(0o777);

src/main.zig+79-21

 @@ -419,9 +419,32 @@ fn mainArgs(
         },
         .targets => {
             dev.check(.targets_command);
+            const self_exe_path = switch (native_os) {
+                .wasi => {},
+                else => process.executablePathAlloc(io, arena) catch |err| fatal("unable to find zig self exe path: {t}", .{err}),
+            };
+            var dirs: std.zig.Directories = .init(
+                arena,
+                io,
+                EnvVar.ZIG_LIB_DIR.get(environ_map),
+                EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map),
+                .global,
+                preopens,
+                self_exe_path,
+                environ_map,
+                try std.zig.getResolvedCwd(io, arena),
+            );
+            defer dirs.deinit(io);
             const host = std.zig.resolveTargetQueryOrFatal(io, .{});
             var stdout_writer = Io.File.stdout().writer(io, &stdout_buffer);
-            try @import("print_targets.zig").cmdTargets(arena, io, cmd_args, &stdout_writer.interface, &host);
+            try @import("print_targets.zig").cmdTargets(
+                arena,
+                io,
+                &dirs,
+                cmd_args,
+                &stdout_writer.interface,
+                &host,
+            );
             return stdout_writer.interface.flush();
         },
         .version => {
 @@ -431,16 +454,31 @@ fn mainArgs(
         },
         .env => {
             dev.check(.env_command);
+            const self_exe_path = switch (native_os) {
+                .wasi => args[0],
+                else => process.executablePathAlloc(io, arena) catch |err| fatal("unable to find zig self exe path: {t}", .{err}),
+            };
+            var dirs: std.zig.Directories = .init(
+                arena,
+                io,
+                EnvVar.ZIG_LIB_DIR.get(environ_map),
+                EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map),
+                .global,
+                preopens,
+                if (native_os != .wasi) self_exe_path,
+                environ_map,
+                try std.zig.getResolvedCwd(io, arena),
+            );
+            defer dirs.deinit(io);
             const host = std.zig.resolveTargetQueryOrFatal(io, .{});
             var stdout_writer = Io.File.stdout().writer(io, &stdout_buffer);
             try @import("print_env.zig").cmdEnv(
                 arena,
-                io,
                 &stdout_writer.interface,
-                args,
-                preopens,
                 &host,
                 environ_map,
+                &dirs,
+                self_exe_path,
             );
             return stdout_writer.interface.flush();
         },
 @@ -3813,9 +3851,14 @@ fn buildOutputType(
     }) {
         dev.checkAny(&.{ .run_command, .test_command });
+        const self_exe_path_or_argv0 = switch (native_os) {
+            .wasi => all_args[0], // Will error because of `!process.can_spawn`
+            else => self_exe_path,
+        };
         if (test_exec_args.items.len == 0 and target.ofmt == .c and emit_bin_resolved != .no) {
             // Default to using `zig run` to execute the produced .c code from `zig test`.
-            try test_exec_args.appendSlice(arena, &.{ self_exe_path, "run" });
+            try test_exec_args.appendSlice(arena, &.{ self_exe_path_or_argv0, "run" });
             // Skip passing `-ofmt`, we want the default for the target, not `.c` anymore.
             var prev_has_cflags = false;
 @@ -3896,7 +3939,7 @@ fn buildOutputType(
             arena,
             io,
             test_exec_args.items,
-            self_exe_path,
+            self_exe_path_or_argv0,
             arg_mode,
             target,
             &comp_destroyed,
 @@ -4287,7 +4330,10 @@ fn serve(
     in: *Io.Reader,
     out: *Io.Writer,
     test_exec_args: []const ?[]const u8,
-    self_exe_path: ?[]const u8,
+    self_exe_path: switch (native_os) {
+        .wasi => void,
+        else => []const u8,
+    },
     arg_mode: ArgMode,
     all_args: []const []const u8,
     runtime_args_start: ?usize,
 @@ -4400,7 +4446,7 @@ fn serve(
                         comp,
                         gpa,
                         test_exec_args,
-                        self_exe_path.?,
+                        self_exe_path,
                         arg_mode,
                         all_args,
                         runtime_args_start,
 @@ -4585,9 +4631,8 @@ fn runOrTest(
         const cmd = try std.mem.join(arena, " ", argv.items);
         fatal("the following command failed to execve with '{t}':\n{s}", .{ err, cmd });
     } else if (!process.can_spawn) {
-        const cmd = try std.mem.join(arena, " ", argv.items);
+        fatal("the following command cannot be executed ({t} does not support spawning a child process):\n{f}", .{
-        fatal("the following command cannot be executed ({t} does not support spawning a child process):\n{s}", .{
+            native_os, std.zig.SubprocessCommand{ .argv = argv.items },
-            native_os, cmd,
         });
     }
     const term_result = (term: {
 @@ -4667,7 +4712,10 @@ fn runOrTestHotSwap(
     comp: *Compilation,
     gpa: Allocator,
     test_exec_args: []const ?[]const u8,
-    self_exe_path: []const u8,
+    self_exe_path: switch (native_os) {
+        .wasi => void,
+        else => []const u8,
+    },
     arg_mode: ArgMode,
     all_args: []const []const u8,
     runtime_args_start: ?usize,
 @@ -4675,6 +4723,11 @@ fn runOrTestHotSwap(
     const io = comp.io;
     const lf = comp.bin_file.?;
+    const self_exe_path_or_argv0 = switch (native_os) {
+        .wasi => all_args[0], // Will error because of `!process.can_spawn`
+        else => self_exe_path,
+    };
     const exe_path = switch (builtin.target.os.tag) {
         // On Windows it seems impossible to perform an atomic rename of a file that is currently
         // running in a process. Therefore, we do the opposite. We create a copy of the file in
 @@ -4700,7 +4753,7 @@ fn runOrTestHotSwap(
         // when testing pass the zig_exe_path to argv
         if (arg_mode == .zig_test)
             try argv.appendSlice(&[_][]const u8{
-                exe_path, self_exe_path,
+                exe_path, self_exe_path_or_argv0,
             })
             // when running just pass the current exe
         else
 @@ -4713,7 +4766,7 @@ fn runOrTestHotSwap(
                 try argv.append(a);
             } else {
                 try argv.appendSlice(&[_][]const u8{
-                    exe_path, self_exe_path,
+                    exe_path, self_exe_path_or_argv0,
                 });
             }
         }
 @@ -4722,6 +4775,12 @@ fn runOrTestHotSwap(
         try argv.appendSlice(all_args[i..]);
     }
+    if (!process.can_spawn) {
+        fatal("the following command cannot be executed ({t} does not support spawning a child process):\n{f}", .{
+            native_os, std.zig.SubprocessCommand{ .argv = argv.items },
+        });
+    }
     const child = try std.process.spawn(io, .{
         .argv = argv.items,
         .stdin = .inherit,
 @@ -4902,6 +4961,12 @@ fn jitCmdInner(
     thread_limit: usize,
     options: JitCmdOptions,
 ) !void {
+    if (!std.process.can_spawn) {
+        fatal("The {s} command cannot be executed ({t} does not support spawning a child process)", .{
+            options.cmd_name, native_os,
+        });
+    }
     const target_query: std.Target.Query = .{};
     const resolved_target: Module.ResolvedTarget = .{
         .result = std.zig.resolveTargetQueryOrFatal(io, target_query),
 @@ -5074,13 +5139,6 @@ fn jitCmdInner(
         fatal("the following command failed to execve with {t}:\n{s}", .{ err, cmd });
     }
-    if (!process.can_spawn) {
-        const cmd = try std.mem.join(arena, " ", child_argv.items);
-        fatal("the following command cannot be executed ({t} does not support spawning a child process):\n{s}", .{
-            native_os, cmd,
-        });
-    }
     const term = t: {
         _ = try io.lockStderr(&.{}, .no_color);
         defer io.unlockStderr();

src/print_env.zig+2-28

...	@@ -11,38 +11,12 @@ const Compilation = @import("Compilation.zig");	...	@@ -11,38 +11,12 @@ const Compilation = @import("Compilation.zig");
11		11
12	pub fn cmdEnv(	12	pub fn cmdEnv(
13	arena: Allocator,	13	arena: Allocator,
14	io: Io,
15	out: *std.Io.Writer,	14	out: *std.Io.Writer,
16	args: []const []const u8,
17	preopens: std.process.Preopens,
18	host: *const std.Target,	15	host: *const std.Target,
19	environ_map: *std.process.Environ.Map,	16	environ_map: *std.process.Environ.Map,
		17	dirs: *const std.zig.Directories,
		18	self_exe_path: []const u8,
20	) !void {	19	) !void {
21	const override_lib_dir: ?[]const u8 = EnvVar.ZIG_LIB_DIR.get(environ_map);
22	const override_global_cache_dir: ?[]const u8 = EnvVar.ZIG_GLOBAL_CACHE_DIR.get(environ_map);
23
24	const self_exe_path = switch (builtin.target.os.tag) {
25	.wasi => args[0],
26	else => std.process.executablePathAlloc(io, arena) catch \|err\| {
27	fatal("unable to find zig self exe path: {t}", .{err});
28	},
29	};
30
31	const cwd_path = try std.zig.getResolvedCwd(io, arena);
32
33	var dirs: std.zig.Directories = .init(
34	arena,
35	io,
36	override_lib_dir,
37	override_global_cache_dir,
38	.global,
39	preopens,
40	if (builtin.target.os.tag != .wasi) self_exe_path,
41	environ_map,
42	cwd_path,
43	);
44	defer dirs.deinit(io);
45
46	const zig_lib_dir = dirs.zig_lib.path orelse "";	20	const zig_lib_dir = dirs.zig_lib.path orelse "";
47	const zig_std_dir = try dirs.zig_lib.join(arena, &.{"std"});	21	const zig_std_dir = try dirs.zig_lib.join(arena, &.{"std"});
48	const global_cache_dir = dirs.global_cache.path orelse "";	22	const global_cache_dir = dirs.global_cache.path orelse "";

src/print_targets.zig+2-5

 @@ -14,16 +14,13 @@ const target = @import("target.zig");
 pub fn cmdTargets(
     allocator: Allocator,
     io: Io,
+    directories: *const std.zig.Directories,
     args: []const []const u8,
     out: *std.Io.Writer,
     native_target: *const Target,
 ) !void {
     _ = args;
-    var zig_lib_directory = std.zig.findZigLibDir(allocator, io) catch |err|
+    const zig_lib_directory = directories.zig_lib;
-        fatal("unable to find zig installation directory: {t}", .{err});
-    defer zig_lib_directory.handle.close(io);
-    defer allocator.free(zig_lib_directory.path.?);
     const abilists_contents = zig_lib_directory.handle.readFileAlloc(
         io,
         glibc.abilists_path,