Commit 67df66c26c

@@ -11,10 +11,14 @@ pub fn main() void {
     var di: std.debug.SelfInfo = .init;
     defer di.deinit(gpa);
 
+    var threaded: std.Io.Threaded = .init(gpa);
+    defer threaded.deinit();
+    const io = threaded.io();
+
     var add_addr: usize = undefined;
     _ = add(1, 2, &add_addr);
 
-    const symbol = di.getSymbol(gpa, add_addr) catch |err| fatal("failed to get symbol: {t}", .{err});
+    const symbol = di.getSymbol(gpa, io, add_addr) catch |err| fatal("failed to get symbol: {t}", .{err});
     defer if (symbol.source_location) |sl| gpa.free(sl.file_name);
 
     if (symbol.name == null) fatal("failed to resolve symbol name", .{});

@@ -15,6 +15,10 @@ pub fn main() !void {
     defer args.deinit();
     _ = args.skip(); // executable name
 
+    var threaded: std.Io.Threaded = .init(gpa);
+    defer threaded.deinit();
+    const io = threaded.io();
+
     const cache_dir_path = args.next() orelse @panic("expected cache directory path argument");
     var cache_dir = try std.fs.cwd().openDir(cache_dir_path, .{});
     defer cache_dir.close();
@@ -30,7 +34,7 @@ pub fn main() !void {
     defer coverage_file.close();
 
     var read_buf: [@sizeOf(abi.SeenPcsHeader)]u8 = undefined;
-    var r = coverage_file.reader(&read_buf);
+    var r = coverage_file.reader(io, &read_buf);
     const pcs_header = r.interface.takeStruct(abi.SeenPcsHeader, native_endian) catch return r.err.?;
 
     if (pcs_header.pcs_len == 0)

@@ -116,12 +116,12 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         .source =
         \\pub fn main() void {
         \\    var stack_trace_buf: [8]usize = undefined;
-        \\    dumpIt(&captureIt(&stack_trace_buf));
+        \\    dumpIt(captureIt(&stack_trace_buf));
         \\}
         \\fn captureIt(buf: []usize) std.builtin.StackTrace {
         \\    return captureItInner(buf);
         \\}
-        \\fn dumpIt(st: *const std.builtin.StackTrace) void {
+        \\fn dumpIt(st: std.builtin.StackTrace) void {
         \\    std.debug.dumpStackTrace(st);
         \\}
         \\fn captureItInner(buf: []usize) std.builtin.StackTrace {
@@ -140,8 +140,8 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         \\    return captureItInner(buf);
         \\                         ^
         \\source.zig:3:22: [address] in main
-        \\    dumpIt(&captureIt(&stack_trace_buf));
-        \\                     ^
+        \\    dumpIt(captureIt(&stack_trace_buf));
+        \\                    ^
         \\
         ,
         .expect_strip =
@@ -157,12 +157,12 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         .source =
         \\pub fn main() void {
         \\    var stack_trace_buf: [8]usize = undefined;
-        \\    dumpIt(&captureIt(&stack_trace_buf));
+        \\    dumpIt(captureIt(&stack_trace_buf));
         \\}
         \\fn captureIt(buf: []usize) std.builtin.StackTrace {
         \\    return captureItInner(buf);
         \\}
-        \\fn dumpIt(st: *const std.builtin.StackTrace) void {
+        \\fn dumpIt(st: std.builtin.StackTrace) void {
         \\    std.debug.dumpStackTrace(st);
         \\}
         \\fn captureItInner(buf: []usize) std.builtin.StackTrace {
@@ -186,12 +186,12 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         \\    t.join();
         \\}
         \\fn threadMain(stack_trace_buf: []usize) void {
-        \\    dumpIt(&captureIt(stack_trace_buf));
+        \\    dumpIt(captureIt(stack_trace_buf));
         \\}
         \\fn captureIt(buf: []usize) std.builtin.StackTrace {
         \\    return captureItInner(buf);
         \\}
-        \\fn dumpIt(st: *const std.builtin.StackTrace) void {
+        \\fn dumpIt(st: std.builtin.StackTrace) void {
         \\    std.debug.dumpStackTrace(st);
         \\}
         \\fn captureItInner(buf: []usize) std.builtin.StackTrace {
@@ -210,8 +210,8 @@ pub fn addCases(cases: *@import("tests.zig").StackTracesContext) void {
         \\    return captureItInner(buf);
         \\                         ^
         \\source.zig:7:22: [address] in threadMain
-        \\    dumpIt(&captureIt(stack_trace_buf));
-        \\                     ^
+        \\    dumpIt(captureIt(stack_trace_buf));
+        \\                    ^
         \\
         ,
         .expect_strip =

@@ -85,8 +85,12 @@ pub fn main() anyerror!void {
         } else try argv.append(arg);
     }
 
+    var threaded: std.Io.Threaded = .init(gpa);
+    defer threaded.deinit();
+    const io = threaded.io();
+
     const sysroot_path = sysroot orelse blk: {
-        const target = try std.zig.system.resolveTargetQuery(.{});
+        const target = try std.zig.system.resolveTargetQuery(io, .{});
         break :blk std.zig.system.darwin.getSdk(allocator, &target) orelse
             fatal("no SDK found; you can provide one explicitly with '--sysroot' flag", .{});
     };

@@ -33,7 +33,7 @@ pub fn main() anyerror!void {
 
     if (positionals.items.len != 1) fatal("expected one positional argument: [dir]", .{});
 
-    var dir = try std.fs.cwd().openDir(positionals.items[0], .{ .no_follow = true });
+    var dir = try std.fs.cwd().openDir(positionals.items[0], .{ .follow_symlinks = false });
     defer dir.close();
     var paths = std.array_list.Managed([]const u8).init(arena);
     try findHeaders(arena, dir, "", &paths);

@@ -39,8 +39,12 @@ pub fn main() !void {
         std.process.exit(1);
     }
 
+    var threaded: std.Io.Threaded = .init(gpa);
+    defer threaded.deinit();
+    const io = threaded.io();
+
     const query = try std.Target.Query.parse(.{ .arch_os_abi = args[1] });
-    const target = try std.zig.system.resolveTargetQuery(query);
+    const target = try std.zig.system.resolveTargetQuery(io, query);
 
     var buffer: [2000]u8 = undefined;
     var stdout_writer = std.fs.File.stdout().writerStreaming(&buffer);

@@ -13,10 +13,16 @@ pub fn main() !void {
     defer arena_instance.deinit();
     const arena = arena_instance.allocator();
 
+    const gpa = arena;
+
     const args = try std.process.argsAlloc(arena);
     const input_file = args[1];
     const output_file = args[2];
 
+    var threaded: std.Io.Threaded = .init(gpa);
+    defer threaded.deinit();
+    const io = threaded.io();
+
     var in_file = try fs.cwd().openFile(input_file, .{ .mode = .read_only });
     defer in_file.close();
 
@@ -28,7 +34,7 @@ pub fn main() !void {
     var out_dir = try fs.cwd().openDir(fs.path.dirname(output_file).?, .{});
     defer out_dir.close();
 
-    var in_file_reader = in_file.reader(&.{});
+    var in_file_reader = in_file.reader(io, &.{});
     const input_file_bytes = try in_file_reader.interface.allocRemaining(arena, .unlimited);
 
     var tokenizer = Tokenizer.init(input_file, input_file_bytes);