stop aliasing symbols of other namespaces

3 files changed, 188 insertions, 195 deletions

diff --git a/build.zig b/build.zig
index 881eee6..c81d5f4 100644
--- a/build.zig
+++ b/build.zig
@@ -5,24 +5,21 @@
 
 const std = @import("std");
 
-const CrossTarget = std.zig.CrossTarget;
-const Target = std.Target;
-
 // Although this function looks imperative, note that its job is to
 // declaratively construct a build graph that will be executed by an external
 // runner.
 pub fn build(b: *std.Build) void {
-    const riscv64_freestanding = CrossTarget{
-        .cpu_arch = Target.Cpu.Arch.riscv64,
-        .os_tag = Target.Os.Tag.freestanding,
-        .ofmt = Target.ObjectFormat.elf,
+    const riscv64_freestanding = std.zig.CrossTarget{
+        .cpu_arch = std.Target.Cpu.Arch.riscv64,
+        .os_tag = std.Target.Os.Tag.freestanding,
+        .ofmt = std.Target.ObjectFormat.elf,
     };
 
     // Standard target options allows the person running `zig build` to choose
     // what target to build for. Here we do not override the defaults, which
     // means any target is allowed, and the default is native. Other options
     // for restricting supported target set are available.
-    const target = b.standardTargetOptions(.{ .whitelist = &[_]CrossTarget{riscv64_freestanding}, .default_target = riscv64_freestanding });
+    const target = b.standardTargetOptions(.{ .whitelist = &[_]std.zig.CrossTarget{riscv64_freestanding}, .default_target = riscv64_freestanding });
 
     // Standard optimization options allow the person running `zig build` to select
     // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
diff --git a/src/fdt.zig b/src/fdt.zig
index 74c987b..67efb53 100644
--- a/src/fdt.zig
+++ b/src/fdt.zig
@@ -6,8 +6,6 @@ const std = @import("std");
 
 const slice = @import("slice.zig");
 
-const mem = std.mem;
-
 pub const ParseError = error{
     BadMagic,
     BadToken,
@@ -36,7 +34,7 @@ pub const Node = struct {
     subnodes: std.ArrayList(Node),
 
     pub fn unitAddr(self: Node) !?usize {
-        var nameSplit = mem.splitScalar(u8, self.name, '@');
+        var nameSplit = std.mem.splitScalar(u8, self.name, '@');
         _ = nameSplit.next();
         const unitAddrStr = nameSplit.next() orelse return null;
 
@@ -55,8 +53,8 @@ pub const PropertyDesc = struct {
 
     pub fn fromPtr(ptr: *PropertyDesc) PropertyDesc {
         return .{
-            .len = mem.bigToNative(u32, ptr.len),
-            .name_offset = mem.bigToNative(u32, ptr.name_offset),
+            .len = std.mem.bigToNative(u32, ptr.len),
+            .name_offset = std.mem.bigToNative(u32, ptr.name_offset),
         };
     }
 };
@@ -119,22 +117,22 @@ pub const Header = struct {
         const hdr = .{
             .raw_hdr = raw_hdr,
 
-            .magic = mem.bigToNative(u32, raw_hdr.magic),
-            .total_size = mem.bigToNative(u32, raw_hdr.total_size),
-            .offset_dt_struct = mem.bigToNative(u32, raw_hdr.offset_dt_struct),
-            .offset_dt_strings = mem.bigToNative(u32, raw_hdr.offset_dt_strings),
-            .offset_mem_reserve_map = mem.bigToNative(u32, raw_hdr.offset_mem_reserve_map),
-            .version = mem.bigToNative(u32, raw_hdr.version),
-            .last_compat_version = mem.bigToNative(u32, raw_hdr.last_compat_version),
+            .magic = std.mem.bigToNative(u32, raw_hdr.magic),
+            .total_size = std.mem.bigToNative(u32, raw_hdr.total_size),
+            .offset_dt_struct = std.mem.bigToNative(u32, raw_hdr.offset_dt_struct),
+            .offset_dt_strings = std.mem.bigToNative(u32, raw_hdr.offset_dt_strings),
+            .offset_mem_reserve_map = std.mem.bigToNative(u32, raw_hdr.offset_mem_reserve_map),
+            .version = std.mem.bigToNative(u32, raw_hdr.version),
+            .last_compat_version = std.mem.bigToNative(u32, raw_hdr.last_compat_version),
 
             // v2
-            .boot_cpuid_phys = mem.bigToNative(u32, raw_hdr.boot_cpuid_phys),
+            .boot_cpuid_phys = std.mem.bigToNative(u32, raw_hdr.boot_cpuid_phys),
 
             // v3
-            .size_dt_strings = mem.bigToNative(u32, raw_hdr.size_dt_strings),
+            .size_dt_strings = std.mem.bigToNative(u32, raw_hdr.size_dt_strings),
 
             // v17
-            .size_dt_struct = mem.bigToNative(u32, raw_hdr.size_dt_struct),
+            .size_dt_struct = std.mem.bigToNative(u32, raw_hdr.size_dt_struct),
         };
 
         if (hdr.magic != magic) {
@@ -156,7 +154,7 @@ pub const Header = struct {
         return @ptrCast(mem_reservations[0..i]);
     }
 
-    pub fn parseTree(self: *const Header, allocator: mem.Allocator) !Tree {
+    pub fn parseTree(self: *const Header, allocator: std.mem.Allocator) !Tree {
         var nodes = std.ArrayList(Node).init(allocator);
 
         var dt_struct_addr = @intFromPtr(self.raw_hdr) + @as(usize, self.offset_dt_struct);
@@ -164,7 +162,7 @@ pub const Header = struct {
         const dt_strings_addr = @intFromPtr(self.raw_hdr) + @as(usize, self.offset_dt_strings);
         const dt_strings: [*:0]const u8 = @ptrFromInt(dt_strings_addr);
 
-        while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(dt_struct_addr)).*) != token_end) {
+        while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(dt_struct_addr)).*) != token_end) {
             const parsed = try parseNode(allocator, dt_struct_addr, dt_strings);
             dt_struct_addr = parsed.addr;
             try nodes.insert(0, parsed.value);
@@ -180,7 +178,7 @@ pub fn findNode(nodes: []const Node, name: []const u8) slice.Filter(Node, []cons
 
 pub fn findNodeExact(nodes: []const Node, name: []const u8) ?struct { usize, Node } {
     for (nodes, 0..) |node, i| {
-        if (mem.eql(u8, node.name, name)) {
+        if (std.mem.eql(u8, node.name, name)) {
             return .{ i, node };
         }
     }
@@ -189,23 +187,23 @@ pub fn findNodeExact(nodes: []const Node, name: []const u8) ?struct { usize, Nod
 }
 
 fn nodeNameFilter(node: Node, name: []const u8) bool {
-    var it = mem.splitScalar(u8, node.name, '@');
+    var it = std.mem.splitScalar(u8, node.name, '@');
     const trueName = it.first();
-    return mem.eql(u8, trueName, name);
+    return std.mem.eql(u8, trueName, name);
 }
 
-fn parseNode(allocator: mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(Node) {
+fn parseNode(allocator: std.mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(Node) {
     var props = std.StringHashMap([]const u8).init(allocator);
     var subnodes = std.ArrayList(Node).init(allocator);
 
     var addr = dt_struct_addr;
 
     // Skip Nop tokens
-    while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
+    while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
         addr += @sizeOf(u32);
     }
 
-    if (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_begin_node) {
+    if (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_begin_node) {
         return ParseError.ExpectedBeginNodeToken;
     }
 
@@ -213,13 +211,13 @@ fn parseNode(allocator: mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]c
 
     const name: [*:0]u8 = @ptrFromInt(addr);
 
-    addr += mem.len(name) + 1;
+    addr += std.mem.len(name) + 1;
 
     // Skip zeroed alignment padding
-    addr += (4 - ((mem.len(name) + 1) % 4)) % 4;
+    addr += (4 - ((std.mem.len(name) + 1) % 4)) % 4;
 
-    while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_end_node) {
-        switch (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*)) {
+    while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_end_node) {
+        switch (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*)) {
             Header.token_prop => {
                 const parsed = try parseProperty(addr, dt_strings);
                 addr = parsed.addr;
@@ -247,7 +245,7 @@ fn parseNode(allocator: mem.Allocator, dt_struct_addr: usize, dt_strings: [*:0]c
     return .{
         .addr = addr,
         .value = .{
-            .name = mem.span(name),
+            .name = std.mem.span(name),
             .props = props,
             .subnodes = subnodes,
         },
@@ -258,11 +256,11 @@ fn parseProperty(dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(
     var addr = dt_struct_addr;
 
     // Skip Nop tokens
-    while (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
+    while (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) == Header.token_nop) {
         addr += @sizeOf(u32);
     }
 
-    if (mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_prop) {
+    if (std.mem.bigToNative(u32, @as(*u32, @ptrFromInt(addr)).*) != Header.token_prop) {
         return ParseError.ExpectedPropToken;
     }
 
@@ -284,7 +282,7 @@ fn parseProperty(dt_struct_addr: usize, dt_strings: [*:0]const u8) !ParseResult(
     return .{
         .addr = addr,
         .value = .{
-            .name = mem.span(name),
+            .name = std.mem.span(name),
             .value = value,
         },
     };
diff --git a/src/pci.zig b/src/pci.zig
index 78fb141..eae1a14 100644
--- a/src/pci.zig
+++ b/src/pci.zig
@@ -6,8 +6,6 @@ const std = @import("std");
 
 const fdt = @import("fdt.zig");
 
-const mem = std.mem;
-
 pub const Error = error{
     NoRootNode,
     NoSoCnode,
@@ -99,139 +97,139 @@ pub const GeneralHeader = packed struct(u384) {
     max_latency: u8,
 
     pub fn getBaseAddr0(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.base_addr0);
+        return std.mem.littleToNative(u32, self.base_addr0);
     }
 
     pub fn getBaseAddr1(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.base_addr1);
+        return std.mem.littleToNative(u32, self.base_addr1);
     }
 
     pub fn getBaseAddr2(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.base_addr2);
+        return std.mem.littleToNative(u32, self.base_addr2);
     }
 
     pub fn getBaseAddr3(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.base_addr3);
+        return std.mem.littleToNative(u32, self.base_addr3);
     }
 
     pub fn getBaseAddr4(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.base_addr4);
+        return std.mem.littleToNative(u32, self.base_addr4);
     }
 
     pub fn getBaseAddr5(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.base_addr5);
+        return std.mem.littleToNative(u32, self.base_addr5);
     }
 
     pub fn getCardBusCisPointer(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.cardbus_cis_pointer);
+        return std.mem.littleToNative(u32, self.cardbus_cis_pointer);
     }
 
     pub fn getSubsystemVendorId(self: *const volatile GeneralHeader) u16 {
-        return mem.littleToNative(u16, self.subsystem_vendor_id);
+        return std.mem.littleToNative(u16, self.subsystem_vendor_id);
     }
 
     pub fn getSubsystemId(self: *const volatile GeneralHeader) u16 {
-        return mem.littleToNative(u16, self.subsystem_id);
+        return std.mem.littleToNative(u16, self.subsystem_id);
     }
 
     pub fn getExpansionRomBaseAddr(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.expansion_rom_base_addr);
+        return std.mem.littleToNative(u32, self.expansion_rom_base_addr);
     }
 
     pub fn getCapabilitiesPointer(self: *const volatile GeneralHeader) u8 {
-        return mem.littleToNative(u8, self.capabilities_pointer);
+        return std.mem.littleToNative(u8, self.capabilities_pointer);
     }
 
     pub fn getReserved0(self: *const volatile GeneralHeader) u24 {
-        return mem.littleToNative(u24, self.reserved0);
+        return std.mem.littleToNative(u24, self.reserved0);
     }
 
     pub fn getReserved1(self: *const volatile GeneralHeader) u32 {
-        return mem.littleToNative(u32, self.reserved1);
+        return std.mem.littleToNative(u32, self.reserved1);
     }
 
     pub fn getInterruptLine(self: *const volatile GeneralHeader) u8 {
-        return mem.littleToNative(u8, self.interrupt_line);
+        return std.mem.littleToNative(u8, self.interrupt_line);
     }
 
     pub fn getInterruptPin(self: *const volatile GeneralHeader) u8 {
-        return mem.littleToNative(u8, self.interrupt_pin);
+        return std.mem.littleToNative(u8, self.interrupt_pin);
     }
 
     pub fn getMinGrant(self: *const volatile GeneralHeader) u8 {
-        return mem.littleToNative(u8, self.min_grant);
+        return std.mem.littleToNative(u8, self.min_grant);
     }
 
     pub fn getMaxLatency(self: *const volatile GeneralHeader) u8 {
-        return mem.littleToNative(u8, self.max_latency);
+        return std.mem.littleToNative(u8, self.max_latency);
     }
 
     pub fn setBaseAddr0(self: *const volatile GeneralHeader, new_base_addr0: u32) void {
-        self.base_addr0 = mem.nativeToLittle(u32, new_base_addr0);
+        self.base_addr0 = std.mem.nativeToLittle(u32, new_base_addr0);
     }
 
     pub fn setBaseAddr1(self: *const volatile GeneralHeader, new_base_addr1: u32) void {
-        self.base_addr1 = mem.nativeToLittle(u32, new_base_addr1);
+        self.base_addr1 = std.mem.nativeToLittle(u32, new_base_addr1);
     }
 
     pub fn setBaseAddr2(self: *const volatile GeneralHeader, new_base_addr2: u32) void {
-        self.base_addr2 = mem.nativeToLittle(u32, new_base_addr2);
+        self.base_addr2 = std.mem.nativeToLittle(u32, new_base_addr2);
     }
 
     pub fn setBaseAddr3(self: *const volatile GeneralHeader, new_base_addr3: u32) void {
-        self.base_addr3 = mem.nativeToLittle(u32, new_base_addr3);
+        self.base_addr3 = std.mem.nativeToLittle(u32, new_base_addr3);
     }
 
     pub fn setBaseAddr4(self: *const volatile GeneralHeader, new_base_addr4: u32) void {
-        self.base_addr4 = mem.nativeToLittle(u32, new_base_addr4);
+        self.base_addr4 = std.mem.nativeToLittle(u32, new_base_addr4);
     }
 
     pub fn setBaseAddr5(self: *const volatile GeneralHeader, new_base_addr5: u32) void {
-        self.base_addr5 = mem.nativeToLittle(u32, new_base_addr5);
+        self.base_addr5 = std.mem.nativeToLittle(u32, new_base_addr5);
     }
 
     pub fn setCardBusCisPointer(self: *const volatile GeneralHeader, new_cardbus_cis_pointer: u32) void {
-        self.cardbus_cis_pointer = mem.nativeToLittle(u32, new_cardbus_cis_pointer);
+        self.cardbus_cis_pointer = std.mem.nativeToLittle(u32, new_cardbus_cis_pointer);
     }
 
     pub fn setSubsystemVendorId(self: *const volatile GeneralHeader, new_subsystem_vendor_id: u16) void {
-        self.subsystem_vendor_id = mem.nativeToLittle(u16, new_subsystem_vendor_id);
+        self.subsystem_vendor_id = std.mem.nativeToLittle(u16, new_subsystem_vendor_id);
     }
 
     pub fn setSubsystemId(self: *const volatile GeneralHeader, new_subsystem_id: u16) void {
-        self.subsystem_id = mem.nativeToLittle(u16, new_subsystem_id);
+        self.subsystem_id = std.mem.nativeToLittle(u16, new_subsystem_id);
     }
 
     pub fn setExpansionRomBaseAddr(self: *const volatile GeneralHeader, new_expansion_rom_base_addr: u32) void {
-        self.expansion_rom_base_addr = mem.nativeToLittle(u32, new_expansion_rom_base_addr);
+        self.expansion_rom_base_addr = std.mem.nativeToLittle(u32, new_expansion_rom_base_addr);
     }
 
     pub fn setCapabilitiesPointer(self: *const volatile GeneralHeader, new_capabilities_pointer: u8) void {
-        self.capabilities_pointer = mem.nativeToLittle(u8, new_capabilities_pointer);
+        self.capabilities_pointer = std.mem.nativeToLittle(u8, new_capabilities_pointer);
     }
 
     pub fn setReserved0(self: *const volatile GeneralHeader, new_reserved0: u24) void {
-        self.reserved0 = mem.nativeToLittle(u24, new_reserved0);
+        self.reserved0 = std.mem.nativeToLittle(u24, new_reserved0);
     }
 
     pub fn setReserved1(self: *const volatile GeneralHeader, new_reserved1: u32) void {
-        self.reserved1 = mem.nativeToLittle(u32, new_reserved1);
+        self.reserved1 = std.mem.nativeToLittle(u32, new_reserved1);
     }
 
     pub fn setInterruptLine(self: *const volatile GeneralHeader, new_interrupt_line: u8) void {
-        self.interrupt_line = mem.nativeToLittle(u8, new_interrupt_line);
+        self.interrupt_line = std.mem.nativeToLittle(u8, new_interrupt_line);
     }
 
     pub fn setInterruptPin(self: *const volatile GeneralHeader, new_interrupt_pin: u8) void {
-        self.interrupt_pin = mem.nativeToLittle(u8, new_interrupt_pin);
+        self.interrupt_pin = std.mem.nativeToLittle(u8, new_interrupt_pin);
     }
 
     pub fn setMinGrant(self: *const volatile GeneralHeader, new_min_grant: u8) void {
-        self.min_grant = mem.nativeToLittle(u8, new_min_grant);
+        self.min_grant = std.mem.nativeToLittle(u8, new_min_grant);
     }
 
     pub fn setMaxLatency(self: *const volatile GeneralHeader, new_max_latency: u8) void {
-        self.max_latency = mem.nativeToLittle(u8, new_max_latency);
+        self.max_latency = std.mem.nativeToLittle(u8, new_max_latency);
     }
 };
 
@@ -261,187 +259,187 @@ pub const Pci2Pciheader = packed struct(u384) {
     bridge_control: u16,
 
     pub fn getBaseAddr0(self: *const volatile Pci2Pciheader) u32 {
-        return mem.littleToNative(u32, self.base_addr0);
+        return std.mem.littleToNative(u32, self.base_addr0);
     }
 
     pub fn getBaseAddr1(self: *const volatile Pci2Pciheader) u32 {
-        return mem.littleToNative(u32, self.base_addr1);
+        return std.mem.littleToNative(u32, self.base_addr1);
     }
 
     pub fn getPrimaryBusNumber(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.primary_bus_number);
+        return std.mem.littleToNative(u8, self.primary_bus_number);
     }
 
     pub fn getSecondaryBusNumber(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.secondary_bus_number);
+        return std.mem.littleToNative(u8, self.secondary_bus_number);
     }
 
     pub fn getSubordinateBusNumber(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.subordinate_bus_number);
+        return std.mem.littleToNative(u8, self.subordinate_bus_number);
     }
 
     pub fn getSecondaryLatencyTimer(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.secondary_latency_timer);
+        return std.mem.littleToNative(u8, self.secondary_latency_timer);
     }
 
     pub fn getIoBase(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.io_base);
+        return std.mem.littleToNative(u8, self.io_base);
     }
 
     pub fn getIoLimit(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.io_limit);
+        return std.mem.littleToNative(u8, self.io_limit);
     }
 
     pub fn getSecondaryStatus(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.secondary_status);
+        return std.mem.littleToNative(u16, self.secondary_status);
     }
 
     pub fn getMemoryBase(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.memory_base);
+        return std.mem.littleToNative(u16, self.memory_base);
     }
 
     pub fn getMemoryLimit(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.memory_limit);
+        return std.mem.littleToNative(u16, self.memory_limit);
     }
 
     pub fn getPrefetchableMemoryBase(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.prefetchable_memory_base);
+        return std.mem.littleToNative(u16, self.prefetchable_memory_base);
     }
 
     pub fn getPrefetchableMemoryLimit(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.prefetchable_memory_limit);
+        return std.mem.littleToNative(u16, self.prefetchable_memory_limit);
     }
 
     pub fn getPrefetchableBaseUpper32Bits(self: *const volatile Pci2Pciheader) u32 {
-        return mem.littleToNative(u32, self.prefetchable_base_upper_32_bits);
+        return std.mem.littleToNative(u32, self.prefetchable_base_upper_32_bits);
     }
 
     pub fn getPrefetchableLimitUpper32Bits(self: *const volatile Pci2Pciheader) u32 {
-        return mem.littleToNative(u32, self.prefetchable_limit_upper_32_bits);
+        return std.mem.littleToNative(u32, self.prefetchable_limit_upper_32_bits);
     }
 
     pub fn getIoBaseUpper16Bits(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.io_base_upper_16_bits);
+        return std.mem.littleToNative(u16, self.io_base_upper_16_bits);
     }
 
     pub fn getIoLimitUpper16Bits(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.io_limit_upper_16_bits);
+        return std.mem.littleToNative(u16, self.io_limit_upper_16_bits);
     }
 
     pub fn getCapabilityPointer(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.capability_pointer);
+        return std.mem.littleToNative(u8, self.capability_pointer);
     }
 
     pub fn getReserved0(self: *const volatile Pci2Pciheader) u24 {
-        return mem.littleToNative(u24, self.reserved0);
+        return std.mem.littleToNative(u24, self.reserved0);
     }
 
     pub fn getExpansionRomBaseAddr(self: *const volatile Pci2Pciheader) u32 {
-        return mem.littleToNative(u32, self.expansion_rom_base_addr);
+        return std.mem.littleToNative(u32, self.expansion_rom_base_addr);
     }
 
     pub fn getInterruptLine(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.interrupt_line);
+        return std.mem.littleToNative(u8, self.interrupt_line);
     }
 
     pub fn getInterruptPin(self: *const volatile Pci2Pciheader) u8 {
-        return mem.littleToNative(u8, self.interrupt_pin);
+        return std.mem.littleToNative(u8, self.interrupt_pin);
     }
 
     pub fn getBridgeControl(self: *const volatile Pci2Pciheader) u16 {
-        return mem.littleToNative(u16, self.bridge_control);
+        return std.mem.littleToNative(u16, self.bridge_control);
     }
 
     pub fn setBaseAddr0(self: *volatile Pci2Pciheader, new_base_addr0: u32) void {
-        self.base_addr0 = mem.nativeToLittle(u32, new_base_addr0);
+        self.base_addr0 = std.mem.nativeToLittle(u32, new_base_addr0);
     }
 
     pub fn setBaseAddr1(self: *volatile Pci2Pciheader, new_base_addr1: u32) void {
-        self.base_addr1 = mem.nativeToLittle(u32, new_base_addr1);
+        self.base_addr1 = std.mem.nativeToLittle(u32, new_base_addr1);
     }
 
     pub fn setPrimaryBusNumber(self: *volatile Pci2Pciheader, new_primary_bus_number: u8) void {
-        self.primary_bus_number = mem.nativeToLittle(u8, new_primary_bus_number);
+        self.primary_bus_number = std.mem.nativeToLittle(u8, new_primary_bus_number);
     }
 
     pub fn setSecondaryBusNumber(self: *volatile Pci2Pciheader, new_secondary_bus_number: u8) void {
-        self.secondary_bus_number = mem.nativeToLittle(u8, new_secondary_bus_number);
+        self.secondary_bus_number = std.mem.nativeToLittle(u8, new_secondary_bus_number);
     }
 
     pub fn setSubordinateBusNumber(self: *volatile Pci2Pciheader, new_subordinate_bus_number: u8) void {
-        self.subordinate_bus_number = mem.nativeToLittle(u8, new_subordinate_bus_number);
+        self.subordinate_bus_number = std.mem.nativeToLittle(u8, new_subordinate_bus_number);
     }
 
     pub fn setSecondaryLatencyTimer(self: *volatile Pci2Pciheader, new_secondary_latency_timer: u8) void {
-        self.secondary_latency_timer = mem.nativeToLittle(u8, new_secondary_latency_timer);
+        self.secondary_latency_timer = std.mem.nativeToLittle(u8, new_secondary_latency_timer);
     }
 
     pub fn setIoBase(self: *volatile Pci2Pciheader, new_io_base: u8) void {
-        self.io_base = mem.nativeToLittle(u8, new_io_base);
+        self.io_base = std.mem.nativeToLittle(u8, new_io_base);
     }
 
     pub fn setIoLimit(self: *volatile Pci2Pciheader, new_io_limit: u8) void {
-        self.io_limit = mem.nativeToLittle(u8, new_io_limit);
+        self.io_limit = std.mem.nativeToLittle(u8, new_io_limit);
     }
 
     pub fn setSecondaryStatus(self: *volatile Pci2Pciheader, new_secondary_status: u16) void {
-        self.secondary_status = mem.nativeToLittle(u16, new_secondary_status);
+        self.secondary_status = std.mem.nativeToLittle(u16, new_secondary_status);
     }
 
     pub fn setMemoryBase(self: *volatile Pci2Pciheader, new_memory_base: u16) void {
-        self.memory_base = mem.nativeToLittle(u16, new_memory_base);
+        self.memory_base = std.mem.nativeToLittle(u16, new_memory_base);
     }
 
     pub fn setMemoryLimit(self: *volatile Pci2Pciheader, new_memory_limit: u16) void {
-        self.memory_limit = mem.nativeToLittle(u16, new_memory_limit);
+        self.memory_limit = std.mem.nativeToLittle(u16, new_memory_limit);
     }
 
     pub fn setPrefetchableMemoryBase(self: *volatile Pci2Pciheader, new_prefetchable_memory_base: u16) void {
-        self.prefetchable_memory_base = mem.nativeToLittle(u16, new_prefetchable_memory_base);
+        self.prefetchable_memory_base = std.mem.nativeToLittle(u16, new_prefetchable_memory_base);
     }
 
     pub fn setPrefetchableMemoryLimit(self: *volatile Pci2Pciheader, new_prefetchable_memory_limit: u16) void {
-        self.prefetchable_memory_limit = mem.nativeToLittle(u16, new_prefetchable_memory_limit);
+        self.prefetchable_memory_limit = std.mem.nativeToLittle(u16, new_prefetchable_memory_limit);
     }
 
     pub fn setPrefetchableBaseUpper32Bits(self: *volatile Pci2Pciheader, new_prefetchable_base_upper_32_bits: u32) void {
-        self.prefetchable_base_upper_32_bits = mem.nativeToLittle(u32, new_prefetchable_base_upper_32_bits);
+        self.prefetchable_base_upper_32_bits = std.mem.nativeToLittle(u32, new_prefetchable_base_upper_32_bits);
     }
 
     pub fn setPrefetchableLimitUpper32Bits(self: *volatile Pci2Pciheader, new_prefetchable_limit_upper_32_bits: u32) void {
-        self.prefetchable_limit_upper_32_bits = mem.nativeToLittle(u32, new_prefetchable_limit_upper_32_bits);
+        self.prefetchable_limit_upper_32_bits = std.mem.nativeToLittle(u32, new_prefetchable_limit_upper_32_bits);
     }
 
     pub fn setIoBaseUpper16Bits(self: *volatile Pci2Pciheader, new_io_base_upper_16_bits: u16) void {
-        self.io_base_upper_16_bits = mem.nativeToLittle(u16, new_io_base_upper_16_bits);
+        self.io_base_upper_16_bits = std.mem.nativeToLittle(u16, new_io_base_upper_16_bits);
     }
 
     pub fn setIoLimitUpper16Bits(self: *volatile Pci2Pciheader, new_io_limit_upper_16_bits: u16) void {
-        self.io_limit_upper_16_bits = mem.nativeToLittle(u16, new_io_limit_upper_16_bits);
+        self.io_limit_upper_16_bits = std.mem.nativeToLittle(u16, new_io_limit_upper_16_bits);
     }
 
     pub fn setCapabilityPointer(self: *volatile Pci2Pciheader, new_capability_pointer: u8) void {
-        self.capability_pointer = mem.nativeToLittle(u8, new_capability_pointer);
+        self.capability_pointer = std.mem.nativeToLittle(u8, new_capability_pointer);
     }
 
     pub fn setReserved0(self: *volatile Pci2Pciheader, new_reserved0: u24) void {
-        self.reserved0 = mem.nativeToLittle(u24, new_reserved0);
+        self.reserved0 = std.mem.nativeToLittle(u24, new_reserved0);
     }
 
     pub fn setExpansionRomBaseAddr(self: *volatile Pci2Pciheader, new_expansion_rom_base_addr: u32) void {
-        self.expansion_rom_base_addr = mem.nativeToLittle(u32, new_expansion_rom_base_addr);
+        self.expansion_rom_base_addr = std.mem.nativeToLittle(u32, new_expansion_rom_base_addr);
     }
 
     pub fn setInterruptLine(self: *volatile Pci2Pciheader, new_interrupt_line: u8) void {
-        self.interrupt_line = mem.nativeToLittle(u8, new_interrupt_line);
+        self.interrupt_line = std.mem.nativeToLittle(u8, new_interrupt_line);
     }
 
     pub fn setInterruptPin(self: *volatile Pci2Pciheader, new_interrupt_pin: u8) void {
-        self.interrupt_pin = mem.nativeToLittle(u8, new_interrupt_pin);
+        self.interrupt_pin = std.mem.nativeToLittle(u8, new_interrupt_pin);
     }
 
     pub fn setBridgeControl(self: *volatile Pci2Pciheader, new_bridge_control: u16) void {
-        self.bridge_control = mem.nativeToLittle(u16, new_bridge_control);
+        self.bridge_control = std.mem.nativeToLittle(u16, new_bridge_control);
     }
 };
 
@@ -470,179 +468,179 @@ pub const Pci2CardBusHeader = packed struct(u448) {
     pc_card_legacy_mode_16_bit_base_addr: u32,
 
     pub fn getCardBusSocketExCaBaseAddr(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.cardbus_socket_exca_base_addr);
+        return std.mem.littleToNative(u32, self.cardbus_socket_exca_base_addr);
     }
 
     pub fn getCapabilitiesListOffset(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.capabilities_list_offset);
+        return std.mem.littleToNative(u8, self.capabilities_list_offset);
     }
 
     pub fn getReserved0(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.reserved0);
+        return std.mem.littleToNative(u8, self.reserved0);
     }
 
     pub fn getSecondaryStatus(self: *const volatile Pci2CardBusHeader) u16 {
-        return mem.littleToNative(u16, self.secondary_status);
+        return std.mem.littleToNative(u16, self.secondary_status);
     }
 
     pub fn getPciBusNumber(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.pci_bus_number);
+        return std.mem.littleToNative(u8, self.pci_bus_number);
     }
 
     pub fn getCardBusBusNumber(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.cardbus_bus_number);
+        return std.mem.littleToNative(u8, self.cardbus_bus_number);
     }
 
     pub fn getSubordinateBusNumber(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.subordinate_bus_number);
+        return std.mem.littleToNative(u8, self.subordinate_bus_number);
     }
 
     pub fn getCardBusLatencyTimer(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.cardbus_latency_timer);
+        return std.mem.littleToNative(u8, self.cardbus_latency_timer);
     }
 
     pub fn getMemoryBaseAddr0(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.memory_base_addr0);
+        return std.mem.littleToNative(u32, self.memory_base_addr0);
     }
 
     pub fn getMemoryLimit0(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.memory_limit0);
+        return std.mem.littleToNative(u32, self.memory_limit0);
     }
 
     pub fn getMemoryBaseAddr1(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.memory_base_addr1);
+        return std.mem.littleToNative(u32, self.memory_base_addr1);
     }
 
     pub fn getMemoryLimit1(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.memory_limit1);
+        return std.mem.littleToNative(u32, self.memory_limit1);
     }
 
     pub fn getIoBaseAddr0(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.io_base_addr0);
+        return std.mem.littleToNative(u32, self.io_base_addr0);
     }
 
     pub fn getIoLimit0(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.io_limit0);
+        return std.mem.littleToNative(u32, self.io_limit0);
     }
 
     pub fn getIoBaseAddr1(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.io_base_addr1);
+        return std.mem.littleToNative(u32, self.io_base_addr1);
     }
 
     pub fn getIoLimit1(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.io_limit1);
+        return std.mem.littleToNative(u32, self.io_limit1);
     }
 
     pub fn getInterruptLine(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.interrupt_line);
+        return std.mem.littleToNative(u8, self.interrupt_line);
     }
 
     pub fn getInterruptPin(self: *const volatile Pci2CardBusHeader) u8 {
-        return mem.littleToNative(u8, self.interrupt_pin);
+        return std.mem.littleToNative(u8, self.interrupt_pin);
     }
 
     pub fn getBridgeControl(self: *const volatile Pci2CardBusHeader) u16 {
-        return mem.littleToNative(u16, self.bridge_control);
+        return std.mem.littleToNative(u16, self.bridge_control);
     }
 
     pub fn getSubsystemDeviceId(self: *const volatile Pci2CardBusHeader) u16 {
-        return mem.littleToNative(u16, self.subsystem_device_id);
+        return std.mem.littleToNative(u16, self.subsystem_device_id);
     }
 
     pub fn getSubsystemVendorId(self: *const volatile Pci2CardBusHeader) u16 {
-        return mem.littleToNative(u16, self.subsystem_vendor_id);
+        return std.mem.littleToNative(u16, self.subsystem_vendor_id);
     }
 
     pub fn getPcCardLegacyMode16BitBaseAddr(self: *const volatile Pci2CardBusHeader) u32 {
-        return mem.littleToNative(u32, self.pc_card_legacy_mode_16_bit_base_addr);
+        return std.mem.littleToNative(u32, self.pc_card_legacy_mode_16_bit_base_addr);
     }
 
     pub fn setCardBusSocketExCaBaseAddr(self: *volatile Pci2CardBusHeader, new_cardbus_socket_exca_base_addr: u32) void {
-        self.cardbus_socket_exca_base_addr = mem.nativeToLittle(u32, new_cardbus_socket_exca_base_addr);
+        self.cardbus_socket_exca_base_addr = std.mem.nativeToLittle(u32, new_cardbus_socket_exca_base_addr);
     }
 
     pub fn setCapabilitiesListOffset(self: *volatile Pci2CardBusHeader, new_capabilities_list_offset: u8) void {
-        self.capabilities_list_offset = mem.nativeToLittle(u8, new_capabilities_list_offset);
+        self.capabilities_list_offset = std.mem.nativeToLittle(u8, new_capabilities_list_offset);
     }
 
     pub fn setReserved0(self: *volatile Pci2CardBusHeader, new_reserved0: u8) void {
-        self.reserved0 = mem.nativeToLittle(u8, new_reserved0);
+        self.reserved0 = std.mem.nativeToLittle(u8, new_reserved0);
     }
 
     pub fn setSecondaryStatus(self: *volatile Pci2CardBusHeader, new_secondary_status: u16) void {
-        self.secondary_status = mem.nativeToLittle(u16, new_secondary_status);
+        self.secondary_status = std.mem.nativeToLittle(u16, new_secondary_status);
     }
 
     pub fn setPciBusNumber(self: *volatile Pci2CardBusHeader, new_pci_bus_number: u8) void {
-        self.pci_bus_number = mem.nativeToLittle(u8, new_pci_bus_number);
+        self.pci_bus_number = std.mem.nativeToLittle(u8, new_pci_bus_number);
     }
 
     pub fn setCardBusBusNumber(self: *volatile Pci2CardBusHeader, new_cardbus_bus_number: u8) void {
-        self.cardbus_bus_number = mem.nativeToLittle(u8, new_cardbus_bus_number);
+        self.cardbus_bus_number = std.mem.nativeToLittle(u8, new_cardbus_bus_number);
     }
 
     pub fn setSubordinateBusNumber(self: *volatile Pci2CardBusHeader, new_subordinate_bus_number: u8) void {
-        self.subordinate_bus_number = mem.nativeToLittle(u8, new_subordinate_bus_number);
+        self.subordinate_bus_number = std.mem.nativeToLittle(u8, new_subordinate_bus_number);
     }
 
     pub fn setCardBusLatencyTimer(self: *volatile Pci2CardBusHeader, new_cardbus_latency_timer: u8) void {
-        self.cardbus_latency_timer = mem.nativeToLittle(u8, new_cardbus_latency_timer);
+        self.cardbus_latency_timer = std.mem.nativeToLittle(u8, new_cardbus_latency_timer);
     }
 
     pub fn setMemoryBaseAddr0(self: *volatile Pci2CardBusHeader, new_memory_base_addr0: u32) void {
-        self.memory_base_addr0 = mem.nativeToLittle(u32, new_memory_base_addr0);
+        self.memory_base_addr0 = std.mem.nativeToLittle(u32, new_memory_base_addr0);
     }
 
     pub fn setMemoryLimit0(self: *volatile Pci2CardBusHeader, new_memory_limit0: u32) void {
-        self.memory_limit0 = mem.nativeToLittle(u32, new_memory_limit0);
+        self.memory_limit0 = std.mem.nativeToLittle(u32, new_memory_limit0);
     }
 
     pub fn setMemoryBaseAddr1(self: *volatile Pci2CardBusHeader, new_memory_base_addr1: u32) void {
-        self.memory_base_addr1 = mem.nativeToLittle(u32, new_memory_base_addr1);
+        self.memory_base_addr1 = std.mem.nativeToLittle(u32, new_memory_base_addr1);
     }
 
     pub fn setMemoryLimit1(self: *volatile Pci2CardBusHeader, new_memory_limit1: u32) void {
-        self.memory_limit1 = mem.nativeToLittle(u32, new_memory_limit1);
+        self.memory_limit1 = std.mem.nativeToLittle(u32, new_memory_limit1);
     }
 
     pub fn setIoBaseAddr0(self: *volatile Pci2CardBusHeader, new_io_base_addr0: u32) void {
-        self.io_base_addr0 = mem.nativeToLittle(u32, new_io_base_addr0);
+        self.io_base_addr0 = std.mem.nativeToLittle(u32, new_io_base_addr0);
     }
 
     pub fn setIoLimit0(self: *volatile Pci2CardBusHeader, new_io_limit0: u32) void {
-        self.io_limit0 = mem.nativeToLittle(u32, new_io_limit0);
+        self.io_limit0 = std.mem.nativeToLittle(u32, new_io_limit0);
     }
 
     pub fn setIoBaseAddr1(self: *volatile Pci2CardBusHeader, new_io_base_addr1: u32) void {
-        self.io_base_addr1 = mem.nativeToLittle(u32, new_io_base_addr1);
+        self.io_base_addr1 = std.mem.nativeToLittle(u32, new_io_base_addr1);
     }
 
     pub fn setIoLimit1(self: *volatile Pci2CardBusHeader, new_io_limit1: u32) void {
-        self.io_limit1 = mem.nativeToLittle(u32, new_io_limit1);
+        self.io_limit1 = std.mem.nativeToLittle(u32, new_io_limit1);
     }
 
     pub fn setInterruptLine(self: *volatile Pci2CardBusHeader, new_interrupt_line: u8) void {
-        self.interrupt_line = mem.nativeToLittle(u8, new_interrupt_line);
+        self.interrupt_line = std.mem.nativeToLittle(u8, new_interrupt_line);
     }
 
     pub fn setInterruptPin(self: *volatile Pci2CardBusHeader, new_interrupt_pin: u8) void {
-        self.interrupt_pin = mem.nativeToLittle(u8, new_interrupt_pin);
+        self.interrupt_pin = std.mem.nativeToLittle(u8, new_interrupt_pin);
     }
 
     pub fn setBridgeControl(self: *volatile Pci2CardBusHeader, new_bridge_control: u16) void {
-        self.bridge_control = mem.nativeToLittle(u16, new_bridge_control);
+        self.bridge_control = std.mem.nativeToLittle(u16, new_bridge_control);
     }
 
     pub fn setSubsystemDeviceId(self: *volatile Pci2CardBusHeader, new_subsystem_device_id: u16) void {
-        self.subsystem_device_id = mem.nativeToLittle(u16, new_subsystem_device_id);
+        self.subsystem_device_id = std.mem.nativeToLittle(u16, new_subsystem_device_id);
     }
 
     pub fn setSubsystemVendorId(self: *volatile Pci2CardBusHeader, new_subsystem_vendor_id: u16) void {
-        self.subsystem_vendor_id = mem.nativeToLittle(u16, new_subsystem_vendor_id);
+        self.subsystem_vendor_id = std.mem.nativeToLittle(u16, new_subsystem_vendor_id);
     }
 
     pub fn setPcCardLegacyMode16BitBaseAddr(self: *volatile Pci2CardBusHeader, new_pc_card_legacy_mode_16_bit_base_addr: u32) void {
-        self.pc_card_legacy_mode_16_bit_base_addr = mem.nativeToLittle(u32, new_pc_card_legacy_mode_16_bit_base_addr);
+        self.pc_card_legacy_mode_16_bit_base_addr = std.mem.nativeToLittle(u32, new_pc_card_legacy_mode_16_bit_base_addr);
     }
 };
 
@@ -663,99 +661,99 @@ pub const CfgSpace = packed struct(u576) {
     header: Header,
 
     pub fn getDeviceId(self: *const volatile CfgSpace) u16 {
-        return mem.littleToNative(u16, self.device_id);
+        return std.mem.littleToNative(u16, self.device_id);
     }
 
     pub fn getVendorId(self: *const volatile CfgSpace) u16 {
-        return mem.littleToNative(u16, self.vendor_id);
+        return std.mem.littleToNative(u16, self.vendor_id);
     }
 
     pub fn getStatus(self: *const volatile CfgSpace) u16 {
-        return mem.littleToNative(u16, self.status);
+        return std.mem.littleToNative(u16, self.status);
     }
 
     pub fn getCommand(self: *const volatile CfgSpace) u16 {
-        return mem.littleToNative(u16, self.command);
+        return std.mem.littleToNative(u16, self.command);
     }
 
     pub fn getClass(self: *const volatile CfgSpace) u8 {
-        return mem.littleToNative(u8, self.class);
+        return std.mem.littleToNative(u8, self.class);
     }
 
     pub fn getSubclass(self: *const volatile CfgSpace) u8 {
-        return mem.littleToNative(u8, self.subclass);
+        return std.mem.littleToNative(u8, self.subclass);
     }
 
     pub fn getProgIf(self: *const volatile CfgSpace) u8 {
-        return mem.littleToNative(u8, self.prog_if);
+        return std.mem.littleToNative(u8, self.prog_if);
     }
 
     pub fn getRevisionId(self: *const volatile CfgSpace) u8 {
-        return mem.littleToNative(u8, self.revision_id);
+        return std.mem.littleToNative(u8, self.revision_id);
     }
 
     pub fn getBist(self: *const volatile CfgSpace) u8 {
-        return mem.littleToNative(u8, self.bist);
+        return std.mem.littleToNative(u8, self.bist);
     }
 
     pub fn getHeaderType(self: *const volatile CfgSpace) HeaderType {
-        return @enumFromInt(mem.littleToNative(u8, self.header_type));
+        return @enumFromInt(std.mem.littleToNative(u8, self.header_type));
     }
 
     pub fn getLatencyTimer(self: *const volatile CfgSpace) u8 {
-        return mem.littleToNative(u8, self.latency_timer);
+        return std.mem.littleToNative(u8, self.latency_timer);
     }
 
     pub fn getCacheLineSize(self: *const volatile CfgSpace) u8 {
-        return mem.littleToNative(u8, self.cache_line_size);
+        return std.mem.littleToNative(u8, self.cache_line_size);
     }
 
     pub fn setDeviceId(self: *volatile CfgSpace, new_device_id: u16) void {
-        self.device_id = mem.nativeToLittle(u16, new_device_id);
+        self.device_id = std.mem.nativeToLittle(u16, new_device_id);
     }
 
     pub fn setVendorId(self: *volatile CfgSpace, new_vendor_id: u16) void {
-        self.vendor_id = mem.nativeToLittle(u16, new_vendor_id);
+        self.vendor_id = std.mem.nativeToLittle(u16, new_vendor_id);
     }
 
     pub fn setStatus(self: *volatile CfgSpace, new_status: u16) void {
-        self.status = mem.nativeToLittle(u16, new_status);
+        self.status = std.mem.nativeToLittle(u16, new_status);
     }
 
     pub fn setCommand(self: *volatile CfgSpace, new_command: u16) void {
-        self.command = mem.nativeToLittle(u16, new_command);
+        self.command = std.mem.nativeToLittle(u16, new_command);
     }
 
     pub fn setClass(self: *volatile CfgSpace, new_class: u8) void {
-        self.class = mem.writeInt(u8, new_class);
+        self.class = std.mem.writeInt(u8, new_class);
     }
 
     pub fn setSubclass(self: *volatile CfgSpace, new_subclass: u8) void {
-        self.subclass = mem.nativeToLittle(u8, new_subclass);
+        self.subclass = std.mem.nativeToLittle(u8, new_subclass);
     }
 
     pub fn setProgIf(self: *volatile CfgSpace, new_prog_if: u8) void {
-        self.prog_if = mem.nativeToLittle(u8, new_prog_if);
+        self.prog_if = std.mem.nativeToLittle(u8, new_prog_if);
     }
 
     pub fn setRevisionId(self: *volatile CfgSpace, new_revision_id: u8) void {
-        self.revision_id = mem.nativeToLittle(u8, new_revision_id);
+        self.revision_id = std.mem.nativeToLittle(u8, new_revision_id);
     }
 
     pub fn setBist(self: *volatile CfgSpace, new_bist: u8) void {
-        self.bist = mem.nativeToLittle(u8, new_bist);
+        self.bist = std.mem.nativeToLittle(u8, new_bist);
     }
 
     pub fn setHeaderType(self: *volatile CfgSpace, new_header_type: HeaderType) void {
-        self.header_type = mem.writeInt(u8, @intFromEnum(new_header_type));
+        self.header_type = std.mem.writeInt(u8, @intFromEnum(new_header_type));
     }
 
     pub fn setLatencyTimer(self: *volatile CfgSpace, new_latency_timer: u8) void {
-        self.latency_timer = mem.nativeToLittle(u8, new_latency_timer);
+        self.latency_timer = std.mem.nativeToLittle(u8, new_latency_timer);
     }
 
     pub fn setCacheLineSize(self: *volatile CfgSpace, new_cache_line_size: u8) void {
-        self.cache_line_size = mem.nativeToLittle(u8, new_cache_line_size);
+        self.cache_line_size = std.mem.nativeToLittle(u8, new_cache_line_size);
     }
 };
 
@@ -767,8 +765,8 @@ pub fn controllerFromFdt(dt: *const fdt.Tree) !Controller {
     const address_cells_bytes = soc[1].props.get("#address-cells") orelse return Error.NoAddrCells;
     const size_cells_bytes = soc[1].props.get("#size-cells") orelse return Error.NoSizeCells;
 
-    const address_cells = 16 * mem.readInt(u32, address_cells_bytes[0..4], .Big);
-    const size_cells = 16 * mem.readInt(u32, size_cells_bytes[0..4], .Big);
+    const address_cells = 16 * std.mem.readInt(u32, address_cells_bytes[0..4], .Big);
+    const size_cells = 16 * std.mem.readInt(u32, size_cells_bytes[0..4], .Big);
 
     var results = fdt.findNode(soc[1].subnodes.items, "pci");
     const node = results.next() orelse return Error.NoPcinode;
@@ -781,15 +779,15 @@ pub fn controllerFromFdt(dt: *const fdt.Tree) !Controller {
 
     if (n < 1) return Error.NoReg;
 
-    const ptr: [*]u8 = @ptrFromInt(unitAddr + mem.readVarInt(usize, reg[0..(address_cells / 8)], .Big));
-    const len = mem.readVarInt(usize, reg[(address_cells / 8) .. (size_cells / 8) + (address_cells / 8)], .Big);
+    const ptr: [*]u8 = @ptrFromInt(unitAddr + std.mem.readVarInt(usize, reg[0..(address_cells / 8)], .Big));
+    const len = std.mem.readVarInt(usize, reg[(address_cells / 8) .. (size_cells / 8) + (address_cells / 8)], .Big);
     const slice = ptr[0..len];
 
     const compatible = node.props.get("compatible") orelse return Error.NoCompatInfo;
 
-    if (mem.eql(u8, compatible, "pci-host-cam-generic\x00")) {
+    if (std.mem.eql(u8, compatible, "pci-host-cam-generic\x00")) {
         return Controller{ .conventional = CamController.init(slice) };
-    } else if (mem.eql(u8, compatible, "pci-host-ecam-generic\x00")) {
+    } else if (std.mem.eql(u8, compatible, "pci-host-ecam-generic\x00")) {
         return Controller{ .enhanced = EcamController.init(slice) };
     } else {
         return Error.Incompatible;