Commit 89f86e46d278a35a613bbc662cdd3f65ffc76ed7 | zig

author	Matthew Lugg <mlugg@mlugg.co.uk> 2026-04-30 10:08:25+01:00
committer	Matthew Lugg <mlugg@mlugg.co.uk> 2026-05-28 08:54:23+01:00
log	89f86e46d278a35a613bbc662cdd3f65ffc76ed7
tree	dfde60a1161cd65aeb0bf975a62c4a4310133ed0
parent	3f1dead2fc5922b588fbfb108f421ca957d6934a
signature	Commit is signed but in an unrecognized format.

std: don't use dyld functions on non-macOS Darwin

65922a2d4 started using some (deprecated but still available) dyld
functions for stack unwinding and debug information on Darwin targets,
because they are significantly faster than `dladdr` (which is the
"correct" thing to use). However, these functions are unavailable on
Darwin targets other than macOS, for instance on iOS. Therefore, on
those targets, we must fall back to the slow `dladdr` path.

1 files changed, 42 insertions(+), 15 deletions(-)

lib
- std
  - debug
    SelfInfo
    MachO.zig

lib/std/debug/SelfInfo/MachO.zig+42-15

 @@ -93,12 +93,28 @@ pub fn getSymbols(
 pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8 {
     _ = si;
     _ = io;
-    // This function is marked as deprecated; however, it is significantly more
+    return getModuleNameInner(address) orelse return error.MissingDebugInfo;
-    // performant than `dladdr` (since the latter also does a very slow symbol
+}
-    // lookup), so let's use it since it's still available.
+fn getModuleNameInner(address: usize) ?[]const u8 {
-    return std.mem.span(std.c.dyld_image_path_containing_address(
+    switch (builtin.target.os.tag) {
-        @ptrFromInt(address),
+        .macos => {
-    ) orelse return error.MissingDebugInfo);
+            // This function is marked as deprecated; however, it is significantly more performant
+            // than `dladdr` (since the latter also does a very slow symbol lookup), so let's just
+            // use it for the better performance since it's still available.
+            return std.mem.span(std.c.dyld_image_path_containing_address(
+                @ptrFromInt(address),
+            ) orelse return null);
+        },
+        else => {
+            // On other Darwin systems, the function used above is entirely unavailable, so we have
+            // no choice but to use the slow `dladdr`.
+            var info: std.c.dl_info = undefined;
+            if (std.c.dladdr(@ptrFromInt(address), &info) == 0) {
+                return null;
+            }
+            return std.mem.span(info.fname);
+        },
+    }
 }
 pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize {
     const gpa = std.debug.getDebugInfoAllocator();
 @@ -446,12 +462,25 @@ fn unwindFrameInner(si: *SelfInfo, io: Io, context: *UnwindContext) !usize {
 /// Acquires the mutex on success.
 fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize) Error!*Module {
-    // This function is marked as deprecated; however, it is significantly more
+    const text_base: *anyopaque = switch (builtin.target.os.tag) {
-    // performant than `dladdr` (since the latter also does a very slow symbol
+        .macos => base: {
-    // lookup), so let's use it since it's still available.
+            // This function is marked as deprecated; however, it is significantly more performant
-    const text_base = std.c._dyld_get_image_header_containing_address(
+            // than `dladdr` (since the latter also does a very slow symbol lookup), so let's just
-        @ptrFromInt(address),
+            // use it for the better performance since it's still available.
-    ) orelse return error.MissingDebugInfo;
+            break :base std.c._dyld_get_image_header_containing_address(
+                @ptrFromInt(address),
+            ) orelse return error.MissingDebugInfo;
+        },
+        else => base: {
+            // On other Darwin systems, the function used above is entirely unavailable, so we have
+            // no choice but to use the slow `dladdr`.
+            var info: std.c.dl_info = undefined;
+            if (std.c.dladdr(@ptrFromInt(address), &info) == 0) {
+                return error.MissingDebugInfo;
+            }
+            break :base info.fbase;
+        },
+    };
     try si.mutex.lock(io);
     errdefer si.mutex.unlock(io);
     const gop = try si.modules.getOrPutAdapted(gpa, @intFromPtr(text_base), Module.Adapter{});
 @@ -563,9 +592,7 @@ const Module = struct {
     fn getFile(module: *Module, gpa: Allocator, io: Io) Error!*MachOFile {
         if (module.file == null) {
-            const path = std.mem.span(
+            const path = getModuleNameInner(module.text_base).?;
-                std.c.dyld_image_path_containing_address(@ptrFromInt(module.text_base)).?,
-            );
             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,