stage2: Add limited WASI support for selfExePath and globalCacheDir

This change adds support for locating the Zig executable and the library
and global cache directories, based on looking in the fixed "/zig" and
"/cache" directories.

Since our argv[0] on WASI is just the basename (any absolute/relative
path information is deleted by the runtime), there's very limited
introspection we can do on WASI, so we rely on these fixed directories.
These can be provided on the command-line using `--mapdir`, as follows:

```
wasmtime --mapdir=/cwd::. --mapdir=/cache::"$HOME/.cache/zig" --mapdir=/zig::./zig-out/ ./zig-out/bin/zig.wasm
```

lib/std/fs.zig

@@ -2547,6 +2547,15 @@ pub const SelfExePathError = os.ReadLinkError || os.SysCtlError || os.RealPathEr
 /// `selfExePath` except allocates the result on the heap.
 /// Caller owns returned memory.
 pub fn selfExePathAlloc(allocator: Allocator) ![]u8 {
+    if (builtin.os.tag == .wasi) {
+        var args = try std.process.argsWithAllocator(allocator);
+        defer args.deinit();
+        // On WASI, argv[0] is always just the basename of the current executable
+        const exe_name = args.next() orelse return error.FileNotFound;
+
+        var buf: [MAX_PATH_BYTES]u8 = undefined;
+        return allocator.dupe(u8, try selfExePathWasi(&buf, exe_name));
+    }
     // Use of MAX_PATH_BYTES here is justified as, at least on one tested Linux
     // system, readlink will completely fail to return a result larger than
     // PATH_MAX even if given a sufficiently large buffer. This makes it
@@ -2643,10 +2652,45 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
             const end_index = std.unicode.utf16leToUtf8(out_buffer, utf16le_slice) catch unreachable;
             return out_buffer[0..end_index];
         },
+        .wasi => @compileError("std.fs.selfExePath not supported for WASI. Use std.fs.selfExePathAlloc instead."),
         else => @compileError("std.fs.selfExePath not supported for this target"),
     }
 }
 
+/// WASI-specific implementation of selfExePath
+///
+/// On WASI argv0 is always just the executable basename, so this function relies
+/// using a fixed executable directory path: "/zig"
+///
+/// This path can be configured in wasmtime using `--mapdir=/zig::/path/to/zig/dir/`
+fn selfExePathWasi(out_buffer: []u8, exe_name: []const u8) SelfExePathError![]const u8 {
+    var allocator = std.heap.FixedBufferAllocator.init(out_buffer);
+    var alloc = allocator.allocator();
+
+    // Check these paths:
+    //  1. "/zig/{exe_name}"
+    //  2. "/zig/bin/{exe_name}"
+    const base_paths_to_check = &[_][]const u8{ "/zig", "/zig/bin" };
+
+    for (base_paths_to_check) |base_path| {
+        const test_path = path.join(alloc, &.{ base_path, path.basename(exe_name) }) catch continue;
+
+        // Make sure it's a file we're pointing to
+        const file = os.fstatat(os.wasi.AT.FDCWD, test_path, 0) catch continue;
+        if (file.filetype != .REGULAR_FILE) continue;
+
+        // Path seems to be valid, let's try to turn it into an absolute path
+        var real_path_buf: [MAX_PATH_BYTES]u8 = undefined;
+        if (os.realpath(test_path, &real_path_buf)) |real_path| {
+            if (real_path.len > out_buffer.len)
+                return error.NameTooLong;
+            mem.copy(u8, out_buffer, real_path);
+            return out_buffer[0..real_path.len];
+        } else |_| continue;
+    }
+    return error.FileNotFound;
+}
+
 /// The result is UTF16LE-encoded.
 pub fn selfExePathW() [:0]const u16 {
     const image_path_name = &os.windows.peb().ProcessParameters.ImagePathName;

src/introspect.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const builtin = @import("builtin");
 const mem = std.mem;
+const os = std.os;
 const fs = std.fs;
 const Compilation = @import("Compilation.zig");
 
@@ -80,5 +81,15 @@ pub fn resolveGlobalCacheDir(allocator: mem.Allocator) ![]u8 {
         }
     }
 
-    return fs.getAppDataDir(allocator, appname);
+    if (builtin.os.tag == .wasi) {
+        // On WASI, we have no way to get an App data dir, so we try to use a fixed
+        // Preopen path "/cache" as a last resort
+        const path = "/cache";
+
+        const file = os.fstatat(os.wasi.AT.FDCWD, path, 0) catch return error.CacheDirUnavailable;
+        if (file.filetype != .DIRECTORY) return error.CacheDirUnavailable;
+        return allocator.dupe(u8, path);
+    } else {
+        return fs.getAppDataDir(allocator, appname);
+    }
 }