std: implement basic io and improve alloc in uefi

lib/std/Thread.zig

@@ -108,6 +108,8 @@ else if (native_os == .linux)
     LinuxThreadImpl
 else if (native_os == .wasi)
     WasiThreadImpl
+else if (native_os == .uefi)
+    UefiThreadImpl
 else
     UnsupportedImpl;
 
@@ -1124,6 +1126,12 @@ const WasiThreadImpl = struct {
     }
 };
 
+const UefiThreadImpl = struct {
+    fn getCurrentId() Id {
+        return 1;
+    }
+};
+
 const LinuxThreadImpl = struct {
     const linux = std.os.linux;
 

lib/std/debug.zig

@@ -505,7 +505,7 @@ pub fn defaultPanic(
 
             if (uefi.system_table.boot_services) |bs| {
                 // ExitData buffer must be allocated using boot_services.allocatePool (spec: page 220)
-                const exit_data: []u16 = uefi.raw_pool_allocator.alloc(u16, exit_msg.len + 1) catch @trap();
+                const exit_data: []u16 = uefi.global_pool_allocator.allocator().alloc(u16, exit_msg.len + 1) catch @trap();
                 @memcpy(exit_data, exit_msg[0..exit_data.len]); // Includes null terminator.
                 _ = bs.exit(uefi.handle, .Aborted, exit_data.len, exit_data.ptr);
             }

lib/std/debug/SelfInfo.zig

@@ -129,6 +129,8 @@ pub fn getModuleForAddress(self: *SelfInfo, address: usize) !*Module {
         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);
     }
@@ -146,6 +148,8 @@ pub fn getModuleNameForAddress(self: *SelfInfo, address: usize) ?[]const u8 {
         return null;
     } else if (comptime builtin.target.isWasm()) {
         return null;
+    } else if (native_os == .uefi) {
+        return null;
     } else {
         return self.lookupModuleNameDl(address);
     }
@@ -500,6 +504,12 @@ fn lookupModuleWasm(self: *SelfInfo, address: usize) !*Module {
     @panic("TODO implement lookup module for Wasm");
 }
 
+fn lookupModuleUefi(self: *SelfInfo, address: usize) !*Module {
+    _ = self;
+    _ = address;
+    @panic("TODO implement lookup module for UEFI");
+}
+
 pub const Module = switch (native_os) {
     .macos, .ios, .watchos, .tvos, .visionos => struct {
         base_address: usize,

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,
 };
 
@@ -52,7 +52,7 @@ pub const MAX_PATH_BYTES = @compileError("deprecated; renamed to 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.

lib/std/fs/Dir.zig

@@ -581,6 +581,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"),
 };
 
@@ -643,6 +659,9 @@ fn iterateImpl(self: Dir, first_iter_start_value: bool) Iterator {
             .end_index = 0,
             .buf = undefined,
         },
+        .uefi => return Iterator{
+            .dir = self,
+        },
         else => @compileError("unimplemented"),
     }
 }
@@ -2787,4 +2806,4 @@ const assert = std.debug.assert;
 const linux = std.os.linux;
 const windows = std.os.windows;
 const native_os = builtin.os.tag;
-const have_flock = @TypeOf(posix.system.flock) != void;
+const have_flock = @hasDecl(posix.system, "flock") and @TypeOf(posix.system.flock) != void;

lib/std/fs/File.zig

@@ -303,6 +303,9 @@ pub fn supportsAnsiEscapeCodes(self: File) bool {
         // stderr is always sanitized.
         return false;
     }
+    if (builtin.os.tag == .uefi) {
+        return false;
+    }
     if (self.isTty()) {
         if (self.handle == posix.STDOUT_FILENO or self.handle == posix.STDERR_FILENO) {
             if (posix.getenvZ("TERM")) |term| {

lib/std/heap.zig

@@ -239,6 +239,8 @@ else if (builtin.target.os.tag == .plan9)
         .ptr = undefined,
         .vtable = &SbrkAllocator(std.os.plan9.sbrk).vtable,
     }
+else if (builtin.target.os.tag == .uefi)
+    std.os.uefi.global_page_allocator.allocator()
 else
     Allocator{
         .ptr = undefined,

lib/std/io.zig

@@ -3,6 +3,7 @@ const builtin = @import("builtin");
 const root = @import("root");
 const c = std.c;
 const is_windows = builtin.os.tag == .windows;
+const is_uefi = builtin.os.tag == .uefi;
 const windows = std.os.windows;
 const posix = std.posix;
 
@@ -23,6 +24,10 @@ fn getStdOutHandle() posix.fd_t {
         return windows.peb().ProcessParameters.hStdOutput;
     }
 
+    if (is_uefi) {
+        return .{ .simple_output = std.os.uefi.system_table.con_out.? };
+    }
+
     if (@hasDecl(root, "os") and @hasDecl(root.os, "io") and @hasDecl(root.os.io, "getStdOutHandle")) {
         return root.os.io.getStdOutHandle();
     }
@@ -43,6 +48,10 @@ fn getStdErrHandle() posix.fd_t {
         return windows.peb().ProcessParameters.hStdError;
     }
 
+    if (is_uefi) {
+        return .{ .simple_output = std.os.uefi.system_table.std_err.? };
+    }
+
     if (@hasDecl(root, "os") and @hasDecl(root.os, "io") and @hasDecl(root.os.io, "getStdErrHandle")) {
         return root.os.io.getStdErrHandle();
     }
@@ -63,6 +72,10 @@ fn getStdInHandle() posix.fd_t {
         return windows.peb().ProcessParameters.hStdInput;
     }
 
+    if (is_uefi) {
+        return .{ .simple_output = std.os.uefi.system_table.con_in.? };
+    }
+
     if (@hasDecl(root, "os") and @hasDecl(root.os, "io") and @hasDecl(root.os.io, "getStdInHandle")) {
         return root.os.io.getStdInHandle();
     }

lib/std/os/uefi.zig

@@ -1,5 +1,7 @@
 const std = @import("../std.zig");
 
+pub const posix = @import("uefi/posix.zig");
+
 /// A protocol is an interface identified by a GUID.
 pub const protocol = @import("uefi/protocol.zig");
 pub const DevicePath = @import("uefi/device_path.zig").DevicePath;
@@ -13,8 +15,31 @@ pub const tables = @import("uefi/tables.zig");
 /// Defaults to .LoaderData, the default data allocation type
 /// used by UEFI applications to allocate pool memory.
 pub var efi_pool_memory_type: tables.MemoryType = .LoaderData;
-pub const pool_allocator = @import("uefi/pool_allocator.zig").pool_allocator;
-pub const raw_pool_allocator = @import("uefi/pool_allocator.zig").raw_pool_allocator;
+
+const allocator = @import("uefi/allocator.zig");
+pub const PageAllocator = allocator.Page;
+pub const PoolAllocator = allocator.Pool;
+pub const RawPoolAllocator = allocator.RawPool;
+
+pub var global_page_allocator = PageAllocator{};
+pub var global_pool_allocator = PoolAllocator{};
+
+pub var working_directory: fd_t = .none;
+
+pub const AT = posix.AT;
+pub const CLOCK = posix.CLOCK;
+pub const LOCK = posix.LOCK;
+pub const NAME_MAX = posix.NAME_MAX;
+pub const O = posix.O;
+pub const PATH_MAX = posix.PATH_MAX;
+pub const PATH_MAX_WIDE = posix.PATH_MAX_WIDE;
+pub const S = posix.S;
+
+pub const utsname = posix.utsname;
+pub const Stat = posix.Stat;
+pub const fd_t = posix.fd_t;
+pub const ino_t = posix.ino_t;
+pub const mode_t = posix.mode_t;
 
 /// The EFI image's handle that is passed to its entry point.
 pub var handle: Handle = undefined;