std.os.uefi: move allocators to heap

Author: RossComputerGuy

lib/std/debug.zig

@@ -609,7 +609,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.global_pool_allocator.allocator().alloc(u16, exit_msg.len + 1) catch @trap();
+                const exit_data: []u16 = std.heap.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/heap.zig

@@ -24,6 +24,8 @@ pub const GeneralPurposeAllocatorConfig = DebugAllocatorConfig;
 /// Deprecated; to be removed after 0.14.0 is tagged.
 pub const GeneralPurposeAllocator = DebugAllocator;
 
+pub const uefi = @import("heap/uefi_allocators.zig");
+
 const memory_pool = @import("heap/memory_pool.zig");
 pub const MemoryPool = memory_pool.MemoryPool;
 pub const MemoryPoolAligned = memory_pool.MemoryPoolAligned;
@@ -355,7 +357,7 @@ else if (builtin.target.isWasm()) .{
     .ptr = undefined,
     .vtable = &SbrkAllocator(std.os.plan9.sbrk).vtable,
 } else if (builtin.target.os.tag == .uefi)
-    std.os.uefi.global_page_allocator.allocator()
+    uefi.global_page_allocator.allocator()
 else
     .{
         .ptr = undefined,

lib/std/os/uefi/allocator.zig renamed to lib/std/heap/uefi_allocators.zig

@@ -1,4 +1,4 @@
-const std = @import("../../std.zig");
+const std = @import("../std.zig");
 
 const mem = std.mem;
 const uefi = std.os.uefi;
@@ -7,13 +7,16 @@ const Allocator = mem.Allocator;
 
 const assert = std.debug.assert;
 
+pub var global_page_allocator = PageAllocator{};
+pub var global_pool_allocator = PoolAllocator{};
+
 /// Allocates memory in pages.
 ///
 /// This allocator is backed by `allocatePages` and is therefore only suitable for usage when Boot Services are available.
-pub const Page = struct {
-    memory_type: uefi.tables.MemoryType = .LoaderData,
+pub const PageAllocator = struct {
+    memory_type: uefi.tables.MemoryType = .loader_data,
 
-    pub fn allocator(self: *Page) Allocator {
+    pub fn allocator(self: *PageAllocator) Allocator {
         return Allocator{
             .ptr = self,
             .vtable = &vtable,
@@ -36,7 +39,7 @@ pub const Page = struct {
         _ = alignment;
         _ = ret_addr;
 
-        const self: *Page = @ptrCast(@alignCast(ctx));
+        const self: *PageAllocator = @ptrCast(@alignCast(ctx));
 
         assert(len > 0);
         const pages = mem.alignForward(usize, len, 4096) / 4096;
@@ -55,7 +58,7 @@ pub const Page = struct {
         _ = alignment;
         _ = ret_addr;
 
-        const self: *Page = @ptrCast(@alignCast(ctx));
+        const self: *PageAllocator = @ptrCast(@alignCast(ctx));
 
         // If the buffer was originally larger than the new length, we can grow or shrink it in place.
         const original_len = mem.alignForward(usize, buf.len, 4096);
@@ -109,10 +112,10 @@ pub const Page = struct {
 /// Supports the full std.mem.Allocator interface, including up to page alignment.
 ///
 /// This allocator is backed by `allocatePool` and is therefore only suitable for usage when Boot Services are available.
-pub const Pool = struct {
-    memory_type: uefi.tables.MemoryType = .LoaderData,
+pub const PoolAllocator = struct {
+    memory_type: uefi.tables.MemoryType = .loader_data,
 
-    pub fn allocator(self: *Pool) Allocator {
+    pub fn allocator(self: *PoolAllocator) Allocator {
         return Allocator{
             .ptr = self,
             .vtable = &vtable,
@@ -142,7 +145,7 @@ pub const Pool = struct {
         ret_addr: usize,
     ) ?[*]u8 {
         _ = ret_addr;
-        const self: *Pool = @ptrCast(@alignCast(ctx));
+        const self: *PoolAllocator = @ptrCast(@alignCast(ctx));
 
         assert(len > 0);
 
@@ -218,10 +221,10 @@ pub const Pool = struct {
 /// Asserts all allocations are at most 8 byte aligned. This is the highest alignment UEFI will give us directly.
 ///
 /// This allocator is backed by `allocatePool` and is therefore only suitable for usage when Boot Services are available.
-pub const RawPool = struct {
+pub const RawPoolAllocator = struct {
     memory_type: uefi.tables.MemoryType = .LoaderData,
 
-    pub fn allocator(self: *RawPool) Allocator {
+    pub fn allocator(self: *RawPoolAllocator) Allocator {
         return Allocator{
             .ptr = self,
             .vtable = &vtable,
@@ -242,7 +245,7 @@ pub const RawPool = struct {
         ret_addr: usize,
     ) ?[*]u8 {
         _ = ret_addr;
-        const self: *RawPool = @ptrCast(@alignCast(ctx));
+        const self: *RawPoolAllocator = @ptrCast(@alignCast(ctx));
 
         // UEFI pool allocations are 8 byte aligned, so we can't do better than that.
         std.debug.assert(@intFromEnum(alignment) <= 3);

lib/std/os/uefi.zig

@@ -14,14 +14,6 @@ pub const tables = @import("uefi/tables.zig");
 /// used by UEFI applications to allocate pool memory.
 pub var efi_pool_memory_type: tables.MemoryType = .loader_data;
 
-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{};
-
 /// The EFI image's handle that is passed to its entry point.
 pub var handle: Handle = undefined;
 

lib/std/os/uefi/tables.zig

@@ -103,10 +103,10 @@ pub const AllocateType = union(Enum) {
     any: void,
 
     /// Allocate any available range of pages whose uppermost address is less than or equal to a specified address.
-    max_address: EfiPhysicalAddress,
+    max_address: PhysicalAddress,
 
     /// Allocate pages at a specified address.
-    at_address: EfiPhysicalAddress,
+    at_address: PhysicalAddress,
 };
 
 pub const PhysicalAddress = u64;

lib/std/os/uefi/tables/boot_services.zig

@@ -16,7 +16,7 @@ const OpenProtocolAttributes = uefi.tables.OpenProtocolAttributes;
 const ProtocolInformationEntry = uefi.tables.ProtocolInformationEntry;
 const EventNotify = uefi.tables.EventNotify;
 const EfiEventNotify = uefi.tables.EfiEventNotify;
-const EfiPhysicalAddress = uefi.tables.EfiPhysicalAddress;
+const PhysicalAddress = uefi.tables.PhysicalAddress;
 const cc = uefi.cc;
 
 /// Boot services are services provided by the system's firmware until the operating system takes
@@ -40,7 +40,7 @@ pub const BootServices = extern struct {
     restoreTpl: *const fn (old_tpl: usize) callconv(cc) void,
 
     /// Allocates memory pages from the system.
-    _allocatePages: *const fn (alloc_type: AllocateType.Enum, mem_type: MemoryType, pages: usize, memory: EfiPhysicalAddress) callconv(cc) Status,
+    _allocatePages: *const fn (alloc_type: AllocateType.Enum, mem_type: MemoryType, pages: usize, memory: PhysicalAddress) callconv(cc) Status,
 
     /// Frees memory pages.
     _freePages: *const fn (memory: [*]align(4096) u8, pages: usize) callconv(cc) Status,
@@ -209,7 +209,7 @@ pub const BootServices = extern struct {
         };
 
         // EFI memory addresses are always 64-bit, even on 32-bit systems
-        const pointer: EfiPhysicalAddress = @intFromPtr(&buffer_addr);
+        const pointer: PhysicalAddress = @intFromPtr(&buffer_addr);
 
         try self._allocatePages(alloc_type, mem_type, pages, pointer).err();
         const addr: [*]align(4096) u8 = @ptrFromInt(buffer_addr);