Merge pull request 'std: migrate all `fs` APIs to `Io`' (#30232) from std.Io-fs into master

Reviewed-on: https://codeberg.org/ziglang/zig/pulls/30232

8 files changed, 106 insertions, 88 deletions

diff --git a/lib/std/debug/ElfFile.zig b/lib/std/debug/ElfFile.zig
index e81943ab49..a101309d22 100644
--- a/lib/std/debug/ElfFile.zig
+++ b/lib/std/debug/ElfFile.zig
@@ -1,5 +1,13 @@
 //! A helper type for loading an ELF file and collecting its DWARF debug information, unwind
 //! information, and symbol table.
+const ElfFile = @This();
+
+const std = @import("std");
+const Io = std.Io;
+const Endian = std.builtin.Endian;
+const Dwarf = std.debug.Dwarf;
+const Allocator = std.mem.Allocator;
+const elf = std.elf;
 
 is_64: bool,
 endian: Endian,
@@ -115,7 +123,8 @@ pub const LoadError = error{
 
 pub fn load(
     gpa: Allocator,
-    elf_file: std.fs.File,
+    io: Io,
+    elf_file: Io.File,
     opt_build_id: ?[]const u8,
     di_search_paths: *const DebugInfoSearchPaths,
 ) LoadError!ElfFile {
@@ -123,7 +132,7 @@ pub fn load(
     errdefer arena_instance.deinit();
     const arena = arena_instance.allocator();
 
-    var result = loadInner(arena, elf_file, null) catch |err| switch (err) {
+    var result = loadInner(arena, io, elf_file, null) catch |err| switch (err) {
         error.CrcMismatch => unreachable, // we passed crc as null
         else => |e| return e,
     };
@@ -148,7 +157,7 @@ pub fn load(
             if (build_id.len < 3) break :build_id;
 
             for (di_search_paths.global_debug) |global_debug| {
-                if (try loadSeparateDebugFile(arena, &result, null, "{s}/.build-id/{x}/{x}.debug", .{
+                if (try loadSeparateDebugFile(arena, io, &result, null, "{s}/.build-id/{x}/{x}.debug", .{
                     global_debug,
                     build_id[0..1],
                     build_id[1..],
@@ -156,7 +165,7 @@ pub fn load(
             }
 
             if (di_search_paths.debuginfod_client) |components| {
-                if (try loadSeparateDebugFile(arena, &result, null, "{s}{s}/{x}/debuginfo", .{
+                if (try loadSeparateDebugFile(arena, io, &result, null, "{s}{s}/{x}/debuginfo", .{
                     components[0],
                     components[1],
                     build_id,
@@ -173,18 +182,18 @@ pub fn load(
 
             const exe_dir = di_search_paths.exe_dir orelse break :debug_link;
 
-            if (try loadSeparateDebugFile(arena, &result, debug_crc, "{s}/{s}", .{
+            if (try loadSeparateDebugFile(arena, io, &result, debug_crc, "{s}/{s}", .{
                 exe_dir,
                 debug_filename,
             })) |mapped| break :load_di mapped;
-            if (try loadSeparateDebugFile(arena, &result, debug_crc, "{s}/.debug/{s}", .{
+            if (try loadSeparateDebugFile(arena, io, &result, debug_crc, "{s}/.debug/{s}", .{
                 exe_dir,
                 debug_filename,
             })) |mapped| break :load_di mapped;
             for (di_search_paths.global_debug) |global_debug| {
                 // This looks like a bug; it isn't. They really do embed the absolute path to the
                 // exe's dirname, *under* the global debug path.
-                if (try loadSeparateDebugFile(arena, &result, debug_crc, "{s}/{s}/{s}", .{
+                if (try loadSeparateDebugFile(arena, io, &result, debug_crc, "{s}/{s}/{s}", .{
                     global_debug,
                     exe_dir,
                     debug_filename,
@@ -358,12 +367,19 @@ const Section = struct {
     const Array = std.enums.EnumArray(Section.Id, ?Section);
 };
 
-fn loadSeparateDebugFile(arena: Allocator, main_loaded: *LoadInnerResult, opt_crc: ?u32, comptime fmt: []const u8, args: anytype) Allocator.Error!?[]align(std.heap.page_size_min) const u8 {
+fn loadSeparateDebugFile(
+    arena: Allocator,
+    io: Io,
+    main_loaded: *LoadInnerResult,
+    opt_crc: ?u32,
+    comptime fmt: []const u8,
+    args: anytype,
+) Allocator.Error!?[]align(std.heap.page_size_min) const u8 {
     const path = try std.fmt.allocPrint(arena, fmt, args);
-    const elf_file = std.fs.cwd().openFile(path, .{}) catch return null;
-    defer elf_file.close();
+    const elf_file = Io.Dir.cwd().openFile(io, path, .{}) catch return null;
+    defer elf_file.close(io);
 
-    const result = loadInner(arena, elf_file, opt_crc) catch |err| switch (err) {
+    const result = loadInner(arena, io, elf_file, opt_crc) catch |err| switch (err) {
         error.OutOfMemory => |e| return e,
         error.CrcMismatch => return null,
         else => return null,
@@ -408,13 +424,14 @@ const LoadInnerResult = struct {
 };
 fn loadInner(
     arena: Allocator,
-    elf_file: std.fs.File,
+    io: Io,
+    elf_file: Io.File,
     opt_crc: ?u32,
 ) (LoadError || error{ CrcMismatch, Streaming, Canceled })!LoadInnerResult {
     const mapped_mem: []align(std.heap.page_size_min) const u8 = mapped: {
         const file_len = std.math.cast(
             usize,
-            elf_file.getEndPos() catch |err| switch (err) {
+            elf_file.length(io) catch |err| switch (err) {
                 error.PermissionDenied => unreachable, // not asking for PROT_EXEC
                 else => |e| return e,
             },
@@ -529,10 +546,3 @@ fn loadInner(
         .mapped_mem = mapped_mem,
     };
 }
-
-const std = @import("std");
-const Endian = std.builtin.Endian;
-const Dwarf = std.debug.Dwarf;
-const ElfFile = @This();
-const Allocator = std.mem.Allocator;
-const elf = std.elf;
diff --git a/lib/std/debug/Info.zig b/lib/std/debug/Info.zig
index 921cd36ab8..34e79227d1 100644
--- a/lib/std/debug/Info.zig
+++ b/lib/std/debug/Info.zig
@@ -5,19 +5,18 @@
 //! Unlike `std.debug.SelfInfo`, this API does not assume the debug information
 //! in question happens to match the host CPU architecture, OS, or other target
 //! properties.
+const Info = @This();
 
 const std = @import("../std.zig");
+const Io = std.Io;
 const Allocator = std.mem.Allocator;
 const Path = std.Build.Cache.Path;
 const assert = std.debug.assert;
 const Coverage = std.debug.Coverage;
 const SourceLocation = std.debug.Coverage.SourceLocation;
-
 const ElfFile = std.debug.ElfFile;
 const MachOFile = std.debug.MachOFile;
 
-const Info = @This();
-
 impl: union(enum) {
     elf: ElfFile,
     macho: MachOFile,
@@ -25,15 +24,25 @@ impl: union(enum) {
 /// Externally managed, outlives this `Info` instance.
 coverage: *Coverage,
 
-pub const LoadError = std.fs.File.OpenError || ElfFile.LoadError || MachOFile.Error || std.debug.Dwarf.ScanError || error{ MissingDebugInfo, UnsupportedDebugInfo };
+pub const LoadError = error{
+    MissingDebugInfo,
+    UnsupportedDebugInfo,
+} || Io.File.OpenError || ElfFile.LoadError || MachOFile.Error || std.debug.Dwarf.ScanError;
 
-pub fn load(gpa: Allocator, path: Path, coverage: *Coverage, format: std.Target.ObjectFormat, arch: std.Target.Cpu.Arch) LoadError!Info {
+pub fn load(
+    gpa: Allocator,
+    io: Io,
+    path: Path,
+    coverage: *Coverage,
+    format: std.Target.ObjectFormat,
+    arch: std.Target.Cpu.Arch,
+) LoadError!Info {
     switch (format) {
         .elf => {
-            var file = try path.root_dir.handle.openFile(path.sub_path, .{});
-            defer file.close();
+            var file = try path.root_dir.handle.openFile(io, path.sub_path, .{});
+            defer file.close(io);
 
-            var elf_file: ElfFile = try .load(gpa, file, null, &.none);
+            var elf_file: ElfFile = try .load(gpa, io, file, null, &.none);
             errdefer elf_file.deinit(gpa);
 
             if (elf_file.dwarf == null) return error.MissingDebugInfo;
@@ -49,7 +58,7 @@ pub fn load(gpa: Allocator, path: Path, coverage: *Coverage, format: std.Target.
             const path_str = try path.toString(gpa);
             defer gpa.free(path_str);
 
-            var macho_file: MachOFile = try .load(gpa, path_str, arch);
+            var macho_file: MachOFile = try .load(gpa, io, path_str, arch);
             errdefer macho_file.deinit(gpa);
 
             return .{
@@ -76,6 +85,7 @@ pub const ResolveAddressesError = Coverage.ResolveAddressesDwarfError || error{U
 pub fn resolveAddresses(
     info: *Info,
     gpa: Allocator,
+    io: Io,
     /// Asserts the addresses are in ascending order.
     sorted_pc_addrs: []const u64,
     /// Asserts its length equals length of `sorted_pc_addrs`.
@@ -88,7 +98,7 @@ pub fn resolveAddresses(
             // Resolving all of the addresses at once unfortunately isn't so easy in Mach-O binaries
             // due to split debug information. For now, we'll just resolve the addreses one by one.
             for (sorted_pc_addrs, output) |pc_addr, *src_loc| {
-                const dwarf, const dwarf_pc_addr = mf.getDwarfForAddress(gpa, pc_addr) catch |err| switch (err) {
+                const dwarf, const dwarf_pc_addr = mf.getDwarfForAddress(gpa, io, pc_addr) catch |err| switch (err) {
                     error.InvalidMachO, error.InvalidDwarf => return error.InvalidDebugInfo,
                     else => |e| return e,
                 };
diff --git a/lib/std/debug/MachOFile.zig b/lib/std/debug/MachOFile.zig
index 3be1b1daff..9e81fb8911 100644
--- a/lib/std/debug/MachOFile.zig
+++ b/lib/std/debug/MachOFile.zig
@@ -27,13 +27,13 @@ pub fn deinit(mf: *MachOFile, gpa: Allocator) void {
     posix.munmap(mf.mapped_memory);
 }
 
-pub fn load(gpa: Allocator, path: []const u8, arch: std.Target.Cpu.Arch) Error!MachOFile {
+pub fn load(gpa: Allocator, io: Io, path: []const u8, arch: std.Target.Cpu.Arch) Error!MachOFile {
     switch (arch) {
         .x86_64, .aarch64 => {},
         else => unreachable,
     }
 
-    const all_mapped_memory = try mapDebugInfoFile(path);
+    const all_mapped_memory = try mapDebugInfoFile(io, path);
     errdefer posix.munmap(all_mapped_memory);
 
     // In most cases, the file we just mapped is a Mach-O binary. However, it could be a "universal
@@ -239,7 +239,7 @@ pub fn load(gpa: Allocator, path: []const u8, arch: std.Target.Cpu.Arch) Error!M
         .text_vmaddr = text_vmaddr,
     };
 }
-pub fn getDwarfForAddress(mf: *MachOFile, gpa: Allocator, vaddr: u64) !struct { *Dwarf, u64 } {
+pub fn getDwarfForAddress(mf: *MachOFile, gpa: Allocator, io: Io, vaddr: u64) !struct { *Dwarf, u64 } {
     const symbol = Symbol.find(mf.symbols, vaddr) orelse return error.MissingDebugInfo;
 
     if (symbol.ofile == Symbol.unknown_ofile) return error.MissingDebugInfo;
@@ -254,7 +254,7 @@ pub fn getDwarfForAddress(mf: *MachOFile, gpa: Allocator, vaddr: u64) !struct {
     const gop = try mf.ofiles.getOrPut(gpa, symbol.ofile);
     if (!gop.found_existing) {
         const name = mem.sliceTo(mf.strings[symbol.ofile..], 0);
-        gop.value_ptr.* = loadOFile(gpa, name);
+        gop.value_ptr.* = loadOFile(gpa, io, name);
     }
     const of = &(gop.value_ptr.* catch |err| return err);
 
@@ -356,7 +356,7 @@ test {
     _ = Symbol;
 }
 
-fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
+fn loadOFile(gpa: Allocator, io: Io, o_file_name: []const u8) !OFile {
     const all_mapped_memory, const mapped_ofile = map: {
         const open_paren = paren: {
             if (std.mem.endsWith(u8, o_file_name, ")")) {
@@ -365,7 +365,7 @@ fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
                 }
             }
             // Not an archive, just a normal path to a .o file
-            const m = try mapDebugInfoFile(o_file_name);
+            const m = try mapDebugInfoFile(io, o_file_name);
             break :map .{ m, m };
         };
 
@@ -373,7 +373,7 @@ fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
 
         const archive_path = o_file_name[0..open_paren];
         const target_name_in_archive = o_file_name[open_paren + 1 .. o_file_name.len - 1];
-        const mapped_archive = try mapDebugInfoFile(archive_path);
+        const mapped_archive = try mapDebugInfoFile(io, archive_path);
         errdefer posix.munmap(mapped_archive);
 
         var ar_reader: Io.Reader = .fixed(mapped_archive);
@@ -511,16 +511,16 @@ fn loadOFile(gpa: Allocator, o_file_name: []const u8) !OFile {
 }
 
 /// Uses `mmap` to map the file at `path` into memory.
-fn mapDebugInfoFile(path: []const u8) ![]align(std.heap.page_size_min) const u8 {
-    const file = std.fs.cwd().openFile(path, .{}) catch |err| switch (err) {
+fn mapDebugInfoFile(io: Io, path: []const u8) ![]align(std.heap.page_size_min) const u8 {
+    const file = Io.Dir.cwd().openFile(io, path, .{}) catch |err| switch (err) {
         error.FileNotFound => return error.MissingDebugInfo,
         else => return error.ReadFailed,
     };
-    defer file.close();
+    defer file.close(io);
 
     const file_len = std.math.cast(
         usize,
-        file.getEndPos() catch return error.ReadFailed,
+        file.length(io) catch return error.ReadFailed,
     ) orelse return error.ReadFailed;
 
     return posix.mmap(
diff --git a/lib/std/debug/Pdb.zig b/lib/std/debug/Pdb.zig
index c10b361f72..3ecfd1b363 100644
--- a/lib/std/debug/Pdb.zig
+++ b/lib/std/debug/Pdb.zig
@@ -1,5 +1,5 @@
 const std = @import("../std.zig");
-const File = std.fs.File;
+const File = std.Io.File;
 const Allocator = std.mem.Allocator;
 const pdb = std.pdb;
 const assert = std.debug.assert;
diff --git a/lib/std/debug/SelfInfo/Elf.zig b/lib/std/debug/SelfInfo/Elf.zig
index 59c0b42451..be76f3a8c2 100644
--- a/lib/std/debug/SelfInfo/Elf.zig
+++ b/lib/std/debug/SelfInfo/Elf.zig
@@ -29,13 +29,12 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
 }
 
 pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
-    _ = io;
     const module = try si.findModule(gpa, address, .exclusive);
     defer si.rwlock.unlock();
 
     const vaddr = address - module.load_offset;
 
-    const loaded_elf = try module.getLoadedElf(gpa);
+    const loaded_elf = try module.getLoadedElf(gpa, io);
     if (loaded_elf.file.dwarf) |*dwarf| {
         if (!loaded_elf.scanned_dwarf) {
             dwarf.open(gpa, native_endian) catch |err| switch (err) {
@@ -180,7 +179,7 @@ comptime {
     }
 }
 pub const UnwindContext = Dwarf.SelfUnwinder;
-pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, context: *UnwindContext) Error!usize {
+pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) Error!usize {
     comptime assert(can_unwind);
 
     {
@@ -201,7 +200,7 @@ pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, context: *UnwindContext) Error
         @memset(si.unwind_cache.?, .empty);
     }
 
-    const unwind_sections = try module.getUnwindSections(gpa);
+    const unwind_sections = try module.getUnwindSections(gpa, io);
     for (unwind_sections) |*unwind| {
         if (context.computeRules(gpa, unwind, module.load_offset, null)) |entry| {
             entry.populate(si.unwind_cache.?);
@@ -261,12 +260,12 @@ const Module = struct {
     };
 
     /// Assumes we already hold an exclusive lock.
-    fn getUnwindSections(mod: *Module, gpa: Allocator) Error![]Dwarf.Unwind {
-        if (mod.unwind == null) mod.unwind = loadUnwindSections(mod, gpa);
+    fn getUnwindSections(mod: *Module, gpa: Allocator, io: Io) Error![]Dwarf.Unwind {
+        if (mod.unwind == null) mod.unwind = loadUnwindSections(mod, gpa, io);
         const us = &(mod.unwind.? catch |err| return err);
         return us.buf[0..us.len];
     }
-    fn loadUnwindSections(mod: *Module, gpa: Allocator) Error!UnwindSections {
+    fn loadUnwindSections(mod: *Module, gpa: Allocator, io: Io) Error!UnwindSections {
         var us: UnwindSections = .{
             .buf = undefined,
             .len = 0,
@@ -284,7 +283,7 @@ const Module = struct {
         } else {
             // There is no `.eh_frame_hdr` section. There may still be an `.eh_frame` or `.debug_frame`
             // section, but we'll have to load the binary to get at it.
-            const loaded = try mod.getLoadedElf(gpa);
+            const loaded = try mod.getLoadedElf(gpa, io);
             // If both are present, we can't just pick one -- the info could be split between them.
             // `.debug_frame` is likely to be the more complete section, so we'll prioritize that one.
             if (loaded.file.debug_frame) |*debug_frame| {
@@ -319,24 +318,24 @@ const Module = struct {
     }
 
     /// Assumes we already hold an exclusive lock.
-    fn getLoadedElf(mod: *Module, gpa: Allocator) Error!*LoadedElf {
-        if (mod.loaded_elf == null) mod.loaded_elf = loadElf(mod, gpa);
+    fn getLoadedElf(mod: *Module, gpa: Allocator, io: Io) Error!*LoadedElf {
+        if (mod.loaded_elf == null) mod.loaded_elf = loadElf(mod, gpa, io);
         return if (mod.loaded_elf.?) |*elf| elf else |err| err;
     }
-    fn loadElf(mod: *Module, gpa: Allocator) Error!LoadedElf {
+    fn loadElf(mod: *Module, gpa: Allocator, io: Io) Error!LoadedElf {
         const load_result = if (mod.name.len > 0) res: {
-            var file = std.fs.cwd().openFile(mod.name, .{}) catch return error.MissingDebugInfo;
-            defer file.close();
-            break :res std.debug.ElfFile.load(gpa, file, mod.build_id, &.native(mod.name));
+            var file = Io.Dir.cwd().openFile(io, mod.name, .{}) catch return error.MissingDebugInfo;
+            defer file.close(io);
+            break :res std.debug.ElfFile.load(gpa, io, file, mod.build_id, &.native(mod.name));
         } else res: {
-            const path = std.fs.selfExePathAlloc(gpa) catch |err| switch (err) {
+            const path = std.process.executablePathAlloc(io, gpa) catch |err| switch (err) {
                 error.OutOfMemory => |e| return e,
                 else => return error.ReadFailed,
             };
             defer gpa.free(path);
-            var file = std.fs.cwd().openFile(path, .{}) catch return error.MissingDebugInfo;
-            defer file.close();
-            break :res std.debug.ElfFile.load(gpa, file, mod.build_id, &.native(path));
+            var file = Io.Dir.cwd().openFile(io, path, .{}) catch return error.MissingDebugInfo;
+            defer file.close(io);
+            break :res std.debug.ElfFile.load(gpa, io, file, mod.build_id, &.native(path));
         };
 
         var elf_file = load_result catch |err| switch (err) {
diff --git a/lib/std/debug/SelfInfo/MachO.zig b/lib/std/debug/SelfInfo/MachO.zig
index dd11b4c8bf..d09493adb0 100644
--- a/lib/std/debug/SelfInfo/MachO.zig
+++ b/lib/std/debug/SelfInfo/MachO.zig
@@ -21,11 +21,10 @@ pub fn deinit(si: *SelfInfo, gpa: Allocator) void {
 }
 
 pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!std.debug.Symbol {
-    _ = io;
     const module = try si.findModule(gpa, address);
     defer si.mutex.unlock();
 
-    const file = try module.getFile(gpa);
+    const file = try module.getFile(gpa, io);
 
     // This is not necessarily the same as the vmaddr_slide that dyld would report. This is
     // because the segments in the file on disk might differ from the ones in memory. Normally
@@ -39,7 +38,7 @@ pub fn getSymbol(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!st
 
     const vaddr = address - vaddr_offset;
 
-    const ofile_dwarf, const ofile_vaddr = file.getDwarfForAddress(gpa, vaddr) catch {
+    const ofile_dwarf, const ofile_vaddr = file.getDwarfForAddress(gpa, io, vaddr) catch {
         // Return at least the symbol name if available.
         return .{
             .name = try file.lookupSymbolName(vaddr),
@@ -107,7 +106,8 @@ pub const UnwindContext = std.debug.Dwarf.SelfUnwinder;
 /// Unwind a frame using MachO compact unwind info (from `__unwind_info`).
 /// If the compact encoding can't encode a way to unwind a frame, it will
 /// defer unwinding to DWARF, in which case `__eh_frame` will be used if available.
-pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, context: *UnwindContext) Error!usize {
+pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) Error!usize {
+    _ = io;
     return unwindFrameInner(si, gpa, context) catch |err| switch (err) {
         error.InvalidDebugInfo,
         error.MissingDebugInfo,
@@ -546,12 +546,12 @@ const Module = struct {
         };
     }
 
-    fn getFile(module: *Module, gpa: Allocator) Error!*MachOFile {
+    fn getFile(module: *Module, gpa: Allocator, io: Io) Error!*MachOFile {
         if (module.file == null) {
             const path = std.mem.span(
                 std.c.dyld_image_path_containing_address(@ptrFromInt(module.text_base)).?,
             );
-            module.file = MachOFile.load(gpa, path, builtin.cpu.arch) catch |err| switch (err) {
+            module.file = MachOFile.load(gpa, io, path, builtin.cpu.arch) catch |err| switch (err) {
                 error.InvalidMachO, error.InvalidDwarf => error.InvalidDebugInfo,
                 error.MissingDebugInfo, error.OutOfMemory, error.UnsupportedDebugInfo, error.ReadFailed => |e| e,
             };
@@ -615,14 +615,14 @@ test {
 }
 
 /// Uses `mmap` to map the file at `path` into memory.
-fn mapDebugInfoFile(path: []const u8) ![]align(std.heap.page_size_min) const u8 {
-    const file = std.fs.cwd().openFile(path, .{}) catch |err| switch (err) {
+fn mapDebugInfoFile(io: Io, path: []const u8) ![]align(std.heap.page_size_min) const u8 {
+    const file = Io.Dir.cwd().openFile(io, path, .{}) catch |err| switch (err) {
         error.FileNotFound => return error.MissingDebugInfo,
         else => return error.ReadFailed,
     };
-    defer file.close();
+    defer file.close(io);
 
-    const file_end_pos = file.getEndPos() catch |err| switch (err) {
+    const file_end_pos = file.length(io) catch |err| switch (err) {
         error.Unexpected => |e| return e,
         else => return error.ReadFailed,
     };
diff --git a/lib/std/debug/SelfInfo/Windows.zig b/lib/std/debug/SelfInfo/Windows.zig
index ddb6bf73f6..99d3e9f926 100644
--- a/lib/std/debug/SelfInfo/Windows.zig
+++ b/lib/std/debug/SelfInfo/Windows.zig
@@ -149,8 +149,9 @@ pub const UnwindContext = struct {
         return ctx.cur.getRegs().bp;
     }
 };
-pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, context: *UnwindContext) Error!usize {
+pub fn unwindFrame(si: *SelfInfo, gpa: Allocator, io: Io, context: *UnwindContext) Error!usize {
     _ = si;
+    _ = io;
     _ = gpa;
 
     const current_regs = context.cur.getRegs();
@@ -204,14 +205,14 @@ const Module = struct {
         coff_section_headers: []coff.SectionHeader,
 
         const MappedFile = struct {
-            file: fs.File,
+            file: Io.File,
             section_handle: windows.HANDLE,
             section_view: []const u8,
-            fn deinit(mf: *const MappedFile) void {
+            fn deinit(mf: *const MappedFile, io: Io) void {
                 const process_handle = windows.GetCurrentProcess();
                 assert(windows.ntdll.NtUnmapViewOfSection(process_handle, @constCast(mf.section_view.ptr)) == .SUCCESS);
                 windows.CloseHandle(mf.section_handle);
-                mf.file.close();
+                mf.file.close(io);
             }
         };
 
@@ -222,7 +223,7 @@ const Module = struct {
                 pdb.file_reader.file.close(io);
                 pdb.deinit();
             }
-            if (di.mapped_file) |*mf| mf.deinit();
+            if (di.mapped_file) |*mf| mf.deinit(io);
 
             var arena = di.arena.promote(gpa);
             arena.deinit();
@@ -314,8 +315,8 @@ const Module = struct {
             );
             if (len == 0) return error.MissingDebugInfo;
             const name_w = name_buffer[0 .. len + 4 :0];
-            var threaded: Io.Threaded = .init_single_threaded;
-            const coff_file = threaded.dirOpenFileWtf16(null, name_w, .{}) catch |err| switch (err) {
+            // TODO eliminate the reference to Io.Threaded.global_single_threaded here
+            const coff_file = Io.Threaded.global_single_threaded.dirOpenFileWtf16(null, name_w, .{}) catch |err| switch (err) {
                 error.Canceled => |e| return e,
                 error.Unexpected => |e| return e,
                 error.FileNotFound => return error.MissingDebugInfo,
@@ -331,7 +332,6 @@ const Module = struct {
                 error.SystemResources,
                 error.WouldBlock,
                 error.AccessDenied,
-                error.ProcessNotFound,
                 error.PermissionDenied,
                 error.NoSpaceLeft,
                 error.DeviceBusy,
@@ -343,7 +343,7 @@ const Module = struct {
                 error.AntivirusInterference,
                 error.ProcessFdQuotaExceeded,
                 error.SystemFdQuotaExceeded,
-                error.FileLocksNotSupported,
+                error.FileLocksUnsupported,
                 error.FileBusy,
                 => return error.ReadFailed,
             };
@@ -387,12 +387,12 @@ const Module = struct {
             const section_view = section_view_ptr.?[0..coff_len];
             coff_obj = coff.Coff.init(section_view, false) catch return error.InvalidDebugInfo;
             break :mapped .{
-                .file = .adaptFromNewApi(coff_file),
+                .file = coff_file,
                 .section_handle = section_handle,
                 .section_view = section_view,
             };
         };
-        errdefer if (mapped_file) |*mf| mf.deinit();
+        errdefer if (mapped_file) |*mf| mf.deinit(io);
 
         const coff_image_base = coff_obj.getImageBase();
 
@@ -432,22 +432,22 @@ const Module = struct {
                 break :pdb null;
             };
             const pdb_file_open_result = if (fs.path.isAbsolute(path)) res: {
-                break :res std.fs.cwd().openFile(path, .{});
+                break :res Io.Dir.cwd().openFile(io, path, .{});
             } else res: {
-                const self_dir = fs.selfExeDirPathAlloc(gpa) catch |err| switch (err) {
+                const self_dir = std.process.executableDirPathAlloc(io, gpa) catch |err| switch (err) {
                     error.OutOfMemory, error.Unexpected => |e| return e,
                     else => return error.ReadFailed,
                 };
                 defer gpa.free(self_dir);
                 const abs_path = try fs.path.join(gpa, &.{ self_dir, path });
                 defer gpa.free(abs_path);
-                break :res std.fs.cwd().openFile(abs_path, .{});
+                break :res Io.Dir.cwd().openFile(io, abs_path, .{});
             };
             const pdb_file = pdb_file_open_result catch |err| switch (err) {
                 error.FileNotFound, error.IsDir => break :pdb null,
                 else => return error.ReadFailed,
             };
-            errdefer pdb_file.close();
+            errdefer pdb_file.close(io);
 
             const pdb_reader = try arena.create(Io.File.Reader);
             pdb_reader.* = pdb_file.reader(io, try arena.alloc(u8, 4096));
diff --git a/lib/std/debug/simple_panic.zig b/lib/std/debug/simple_panic.zig
index 45e97777c4..a5a09fa116 100644
--- a/lib/std/debug/simple_panic.zig
+++ b/lib/std/debug/simple_panic.zig
@@ -14,9 +14,8 @@ const std = @import("../std.zig");
 pub fn call(msg: []const u8, ra: ?usize) noreturn {
     @branchHint(.cold);
     _ = ra;
-    std.debug.lockStdErr();
-    const stderr: std.fs.File = .stderr();
-    stderr.writeAll(msg) catch {};
+    const stderr_writer = &std.debug.lockStderr(&.{}).file_writer.interface;
+    stderr_writer.writeAll(msg) catch {};
     @trap();
 }