Improvements for UEFI

lib/std/Build/Cache.zig

@@ -930,7 +930,7 @@ pub const Manifest = struct {
         // WASI does not currently support flock, so we bypass it here.
         // TODO: If/when flock is supported on WASI, this check should be removed.
         //       See https://github.com/WebAssembly/wasi-filesystem/issues/2
-        if (builtin.os.tag != .wasi or std.process.can_spawn or !builtin.single_threaded) {
+        if (builtin.os.tag != .wasi or builtin.os.tag != .uefi or std.process.can_spawn or !builtin.single_threaded) {
             const manifest_file = self.manifest_file.?;
             try manifest_file.downgradeLock();
         }
@@ -945,7 +945,7 @@ pub const Manifest = struct {
         // WASI does not currently support flock, so we bypass it here.
         // TODO: If/when flock is supported on WASI, this check should be removed.
         //       See https://github.com/WebAssembly/wasi-filesystem/issues/2
-        if (builtin.os.tag != .wasi or std.process.can_spawn or !builtin.single_threaded) {
+        if (builtin.os.tag != .wasi or builtin.os.tag != .uefi or std.process.can_spawn or !builtin.single_threaded) {
             const manifest_file = self.manifest_file.?;
             // Here we intentionally have a period where the lock is released, in case there are
             // other processes holding a shared lock.

lib/std/builtin.zig

@@ -784,54 +784,6 @@ pub fn default_panic(msg: []const u8, error_return_trace: ?*StackTrace, ret_addr
             std.debug.print("{s}", .{msg});
             std.posix.abort();
         },
-        .uefi => {
-            const uefi = std.os.uefi;
-
-            const ExitData = struct {
-                pub fn create_exit_data(exit_msg: []const u8, exit_size: *usize) ![*:0]u16 {
-                    // Need boot services for pool allocation
-                    if (uefi.system_table.boot_services == null) {
-                        return error.BootServicesUnavailable;
-                    }
-
-                    // ExitData buffer must be allocated using boot_services.allocatePool
-                    var utf16: []u16 = try uefi.raw_pool_allocator.alloc(u16, 256);
-                    errdefer uefi.raw_pool_allocator.free(utf16);
-
-                    if (exit_msg.len > 255) {
-                        return error.MessageTooLong;
-                    }
-
-                    var fmt: [256]u8 = undefined;
-                    const slice = try std.fmt.bufPrint(&fmt, "\r\nerr: {s}\r\n", .{exit_msg});
-                    const len = try std.unicode.utf8ToUtf16Le(utf16, slice);
-
-                    utf16[len] = 0;
-
-                    exit_size.* = 256;
-
-                    return @as([*:0]u16, @ptrCast(utf16.ptr));
-                }
-            };
-
-            var exit_size: usize = 0;
-            const exit_data = ExitData.create_exit_data(msg, &exit_size) catch null;
-
-            if (exit_data) |data| {
-                if (uefi.system_table.std_err) |out| {
-                    _ = out.setAttribute(uefi.protocol.SimpleTextOutput.red);
-                    _ = out.outputString(data);
-                    _ = out.setAttribute(uefi.protocol.SimpleTextOutput.white);
-                }
-            }
-
-            if (uefi.system_table.boot_services) |bs| {
-                _ = bs.exit(uefi.handle, .Aborted, exit_size, exit_data);
-            }
-
-            // Didn't have boot_services, just fallback to whatever.
-            std.posix.abort();
-        },
         .cuda, .amdhsa => std.posix.abort(),
         .plan9 => {
             var status: [std.os.plan9.ERRMAX]u8 = undefined;

lib/std/child_process.zig

@@ -19,7 +19,7 @@ const native_os = builtin.os.tag;
 pub const ChildProcess = struct {
     pub const Id = switch (native_os) {
         .windows => windows.HANDLE,
-        .wasi => void,
+        .wasi, .uefi => void,
         else => posix.pid_t,
     };
 
@@ -47,10 +47,16 @@ pub const ChildProcess = struct {
     stderr_behavior: StdIo,
 
     /// Set to change the user id when spawning the child process.
-    uid: if (native_os == .windows or native_os == .wasi) void else ?posix.uid_t,
+    uid: switch (native_os) {
+        .windows, .wasi, .uefi => void,
+        else => ?posix.uid_t,
+    },
 
     /// Set to change the group id when spawning the child process.
-    gid: if (native_os == .windows or native_os == .wasi) void else ?posix.gid_t,
+    gid: switch (native_os) {
+        .windows, .wasi, .uefi => void,
+        else => ?posix.gid_t,
+    },
 
     /// Set to change the current working directory when spawning the child process.
     cwd: ?[]const u8,
@@ -169,8 +175,14 @@ pub const ChildProcess = struct {
             .term = null,
             .env_map = null,
             .cwd = null,
-            .uid = if (native_os == .windows or native_os == .wasi) {} else null,
-            .gid = if (native_os == .windows or native_os == .wasi) {} else null,
+            .uid = switch (native_os) {
+                .windows, .wasi, .uefi => {},
+                else => null,
+            },
+            .gid = switch (native_os) {
+                .windows, .wasi, .uefi => {},
+                else => null,
+            },
             .stdin = null,
             .stdout = null,
             .stderr = null,

lib/std/debug.zig

@@ -14,6 +14,7 @@ const pdb = std.pdb;
 const root = @import("root");
 const File = std.fs.File;
 const windows = std.os.windows;
+const uefi = std.os.uefi;
 const native_arch = builtin.cpu.arch;
 const native_os = builtin.os.tag;
 const native_endian = native_arch.endian();
@@ -687,6 +688,22 @@ pub const StackIterator = struct {
             }
 
             return true;
+        } else if (native_os == .uefi) {
+            if (uefi.system_table.boot_services) |boot_services| {
+                var map = boot_services.getMemoryMap(std.heap.page_allocator) catch return true;
+                defer map.deinit(std.heap.page_allocator);
+
+                var it = map.iterator();
+                while (it.next()) |entry| {
+                    if (entry.physical_start <= address and address < entry.physical_start + entry.number_of_pages * mem.page_size) {
+                        return true;
+                    }
+                }
+
+                return false;
+            } else {
+                return true;
+            }
         } else if (@hasDecl(posix.system, "msync") and native_os != .wasi and native_os != .emscripten) {
             posix.msync(aligned_memory, posix.MSF.ASYNC) catch |err| {
                 switch (err) {
@@ -792,7 +809,11 @@ pub fn writeCurrentStackTrace(
     } else null) orelse StackIterator.init(start_addr, null);
     defer it.deinit();
 
+    // When true, the stack unwinder failed completely to produce a single frame.
+    var stack_unwind_missing = true;
     while (it.next()) |return_address| {
+        stack_unwind_missing = false;
+
         printLastUnwindError(&it, debug_info, out_stream, tty_config);
 
         // On arm64 macOS, the address of the last frame is 0x0 rather than 0x1 as on x86_64 macOS,
@@ -803,6 +824,11 @@ pub fn writeCurrentStackTrace(
         const address = if (return_address == 0) return_address else return_address - 1;
         try printSourceAtAddress(debug_info, out_stream, address, tty_config);
     } else printLastUnwindError(&it, debug_info, out_stream, tty_config);
+
+    // If the stack unwinder failed, print the top level frame via the given start_addr if available. This is not ideal, but it is better than nothing.
+    if (stack_unwind_missing and start_addr != null) {
+        try printSourceAtAddress(debug_info, out_stream, start_addr.?, tty_config);
+    }
 }
 
 pub noinline fn walkStackWindows(addresses: []usize, existing_context: ?*const windows.CONTEXT) usize {
@@ -1051,6 +1077,7 @@ pub fn openSelfDebugInfo(allocator: mem.Allocator) OpenSelfDebugInfoError!DebugI
             .solaris,
             .illumos,
             .windows,
+            .uefi,
             => return try DebugInfo.init(allocator),
             else => return error.UnsupportedOperatingSystem,
         }
@@ -1090,7 +1117,11 @@ fn readCoffDebugInfo(allocator: mem.Allocator, coff_obj: *coff.Coff) !ModuleDebu
             di.dwarf = dwarf;
         }
 
-        const raw_path = try coff_obj.getPdbPath() orelse return di;
+        const raw_path = if (native_os == .uefi) // this is a workaround because pdb paths are never UEFI paths
+            std.fs.path.basenameWindows(try coff_obj.getPdbPath() orelse return di)
+        else
+            try coff_obj.getPdbPath() orelse return di;
+
         const path = blk: {
             if (fs.path.isAbsolute(raw_path)) {
                 break :blk raw_path;
@@ -1758,6 +1789,8 @@ pub const DebugInfo = struct {
             return self.lookupModuleHaiku(address);
         } else if (comptime builtin.target.isWasm()) {
             return self.lookupModuleWasm(address);
+        } else if (native_os == .uefi) {
+            return self.lookupModuleUefi(address);
         } else {
             return self.lookupModuleDl(address);
         }
@@ -1775,6 +1808,8 @@ pub const DebugInfo = struct {
             return null;
         } else if (comptime builtin.target.isWasm()) {
             return null;
+        } else if (native_os == .uefi) {
+            return null;
         } else {
             return self.lookupModuleNameDl(address);
         }
@@ -1983,6 +2018,37 @@ pub const DebugInfo = struct {
         return null;
     }
 
+    fn lookupModuleUefi(self: *DebugInfo, address: usize) !*ModuleDebugInfo {
+        if (uefi.system_table.boot_services) |boot_services| {
+            const handles = try boot_services.locateHandleBuffer(.{ .by_protocol = &uefi.protocol.LoadedImage.guid });
+            defer boot_services.freePool(mem.sliceAsBytes(handles));
+
+            for (handles) |handle| {
+                const loaded_image: *const uefi.protocol.LoadedImage = try boot_services.openProtocol(handle, uefi.protocol.LoadedImage, .{});
+
+                if (address >= @intFromPtr(loaded_image.image_base) and address < @intFromPtr(loaded_image.image_base) + loaded_image.image_size) {
+                    if (self.address_map.get(@intFromPtr(loaded_image.image_base))) |obj_di| {
+                        return obj_di;
+                    }
+
+                    const obj_di = try self.allocator.create(ModuleDebugInfo);
+                    errdefer self.allocator.destroy(obj_di);
+
+                    const mapped_module = @as([*]const u8, @ptrFromInt(@intFromPtr(loaded_image.image_base)))[0..loaded_image.image_size];
+                    var coff_obj = try coff.Coff.init(mapped_module, true);
+
+                    obj_di.* = try readCoffDebugInfo(self.allocator, &coff_obj);
+                    obj_di.base_address = @intFromPtr(loaded_image.image_base);
+
+                    try self.address_map.putNoClobber(@intFromPtr(loaded_image.image_base), obj_di);
+                    return obj_di;
+                }
+            }
+        }
+
+        return error.MissingDebugInfo;
+    }
+
     fn lookupModuleNameDl(self: *DebugInfo, address: usize) ?[]const u8 {
         _ = self;
 
@@ -2416,10 +2482,11 @@ pub const ModuleDebugInfo = switch (native_os) {
             _ = allocator;
             _ = address;
 
-            return switch (self.debug_data) {
-                .dwarf => |*dwarf| dwarf,
-                else => null,
-            };
+            if (self.dwarf) |*dwarf| {
+                return dwarf;
+            }
+
+            return null;
         }
     },
     .linux, .netbsd, .freebsd, .dragonfly, .openbsd, .haiku, .solaris, .illumos => struct {

lib/std/fs.zig

@@ -20,7 +20,7 @@ pub const File = @import("fs/File.zig");
 pub const path = @import("fs/path.zig");
 
 pub const has_executable_bit = switch (native_os) {
-    .windows, .wasi => false,
+    .windows, .wasi, .uefi => false,
     else => true,
 };
 
@@ -53,7 +53,7 @@ pub const MAX_PATH_BYTES = max_path_bytes;
 /// * On other platforms, `[]u8` file paths are opaque sequences of bytes with
 ///   no particular encoding.
 pub const max_path_bytes = switch (native_os) {
-    .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .haiku, .solaris, .illumos, .plan9, .emscripten, .wasi => posix.PATH_MAX,
+    .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .haiku, .solaris, .illumos, .plan9, .emscripten, .wasi, .uefi => posix.PATH_MAX,
     // Each WTF-16LE code unit may be expanded to 3 WTF-8 bytes.
     // If it would require 4 WTF-8 bytes, then there would be a surrogate
     // pair in the WTF-16LE, and we (over)account 3 bytes for it that way.
@@ -74,7 +74,7 @@ pub const max_path_bytes = switch (native_os) {
 /// On WASI, file name components are encoded as valid UTF-8.
 /// On other platforms, `[]u8` components are an opaque sequence of bytes with no particular encoding.
 pub const MAX_NAME_BYTES = switch (native_os) {
-    .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .solaris, .illumos => posix.NAME_MAX,
+    .linux, .macos, .ios, .freebsd, .openbsd, .netbsd, .dragonfly, .solaris, .illumos, .uefi => posix.NAME_MAX,
     // Haiku's NAME_MAX includes the null terminator, so subtract one.
     .haiku => posix.NAME_MAX - 1,
     // Each WTF-16LE character may be expanded to 3 WTF-8 bytes.
@@ -682,6 +682,31 @@ pub fn selfExePath(out_buffer: []u8) SelfExePathError![]u8 {
                 else => |e| return e,
             };
         },
+        .uefi => {
+            const uefi = std.os.uefi;
+
+            if (uefi.system_table.boot_services) |boot_services| {
+                const loaded_image = boot_services.openProtocol(uefi.handle, uefi.protocol.LoadedImage, .{}) catch return error.FileNotFound;
+
+                const file_path = if (loaded_image.file_path.node()) |node| file_path: {
+                    if (node == .media and node.media == .file_path)
+                        break :file_path node.media.file_path.path();
+
+                    return error.FileNotFound;
+                } else return error.FileNotFound;
+
+                if (file_path.len > uefi.PATH_MAX_WIDE) return error.NameTooLong;
+
+                // required because device paths are not aligned
+                var alignment_buffer: [uefi.PATH_MAX_WIDE]u16 = undefined;
+                @memcpy(alignment_buffer[0..file_path.len], file_path);
+
+                const len = std.unicode.wtf16LeToWtf8(out_buffer, alignment_buffer[0..file_path.len]);
+                return out_buffer[0..len];
+            }
+
+            return error.FileNotFound;
+        },
         else => @compileError("std.fs.selfExePath not supported for this target"),
     }
 }

lib/std/fs/Dir.zig

@@ -579,6 +579,22 @@ pub const Iterator = switch (native_os) {
             self.cookie = std.os.wasi.DIRCOOKIE_START;
         }
     },
+    .uefi => struct {
+        dir: Dir,
+
+        const Self = @This();
+
+        pub const Error = IteratorError;
+
+        pub fn next(self: *Self) Error!?Entry {
+            _ = self;
+            return null;
+        }
+
+        pub fn reset(self: *Self) void {
+            _ = self;
+        }
+    },
     else => @compileError("unimplemented"),
 };
 
@@ -641,6 +657,9 @@ fn iterateImpl(self: Dir, first_iter_start_value: bool) Iterator {
             .end_index = 0,
             .buf = undefined,
         },
+        .uefi => return Iterator{
+            .dir = self,
+        },
         else => @compileError("unimplemented"),
     }
 }

lib/std/fs/File.zig

@@ -255,6 +255,10 @@ pub fn supportsAnsiEscapeCodes(self: File) bool {
 
         return self.isCygwinPty();
     }
+    if (builtin.os.tag == .uefi) {
+        // The UEFI console only supports a tiny subset of ANSI escape codes, primarily for color.
+        return false;
+    }
     if (builtin.os.tag == .wasi) {
         // WASI sanitizes stdout when fd is a tty so ANSI escape codes
         // will not be interpreted as actual cursor commands, and
@@ -455,7 +459,6 @@ pub fn stat(self: File) StatError!Stat {
             .ctime = windows.fromSysTime(info.BasicInformation.ChangeTime),
         };
     }
-
     if (builtin.os.tag == .wasi and !builtin.link_libc) {
         const st = try std.os.fstat_wasi(self.handle);
         return Stat.fromWasi(st);

lib/std/fs/get_app_data_dir.zig

@@ -51,12 +51,13 @@ pub fn getAppDataDir(allocator: mem.Allocator, appname: []const u8) GetAppDataDi
                 else => return error.AppDataDirUnavailable,
             }
         },
+        .uefi => return std.process.getCwdAlloc(allocator) catch error.AppDataDirUnavailable,
         else => @compileError("Unsupported OS"),
     }
 }
 
 test getAppDataDir {
-    if (native_os == .wasi) return error.SkipZigTest;
+    if (native_os == .wasi or native_os == .uefi) return error.SkipZigTest;
 
     // We can't actually validate the result
     const dir = getAppDataDir(std.testing.allocator, "zig") catch return;