Add dSYM mapper

Author: LunaTheFoxgirl

runtime/druntime/src/core/internal/backtrace/dwarf.d

@@ -185,18 +185,12 @@ int traceHandlerOpApplyImpl(size_t numFrames,
             startIdx = idx + 1;
     }
 
-    // Symbolicate locations
-    rt_dwarfSymbolicate(locations[startIdx .. $]);
-
     if (!image.isValid())
         return locations[startIdx .. $].processCallstack(null, 0, dg);
 
     // find address -> file, line mapping using dwarf debug_line
     return image.processDebugLineSectionData(
         (line) => locations[startIdx .. $].processCallstack(line, image.baseAddress, dg));
-
-    // Allow cleaning up after ourselves.
-    rt_dwarfSymbolicateCleanup(locations[startIdx .. $]);
 }
 
 struct TraceInfoBuffer
@@ -243,31 +237,6 @@ struct TraceInfoBuffer
     }
 }
 
-/**
- * A weakly linked hook which can be implemented by external libraries
- * to extend the symbolication capabilites when debug info is missing.
- * 
- * NOTE:
- *   There used to be an atos based symbolication implementation built in
- *   here, but atos is not a portable solution on darwin derived OSes.
- *   atos conflicts with things such as the hardened runtime, iOS releases,
- *   App Store certification and the like. I've removed that implementation
- *   to ensure that D can easily be used to publish to the App Store.
- *   Please avoid adding other private APIs in its place directly in to
- *   druntime. If it resides in PrivateFrameworks or is a dev tool, 
- *   don't use it. - Luna
-*/
-@weak
-extern(C) void rt_dwarfSymbolicate(Location[] locations)
-{
-}
-
-/// ditto
-@weak
-extern(C) void rt_dwarfSymbolicateCleanup(Location[] locations)
-{
-}
-
 private:
 
 int processCallstack(Location[] locations, const(ubyte)[] debugLineSectionData,

runtime/druntime/src/core/internal/backtrace/macho.d

@@ -20,32 +20,37 @@ else version (WatchOS)
 version (Darwin):
 
 import core.stdc.config : c_ulong;
-import core.sys.darwin.crt_externs : _NSGetMachExecuteHeader;
-import core.sys.darwin.mach.getsect : mach_header_64, getsectiondata;
-
-struct Image
-{
-    private mach_header_64* self;
+import core.stdc.stdlib : free;
+import core.internal.macho.dl;
+import core.internal.macho.io;
+
+struct Image {
+    SharedObject self;
+    SharedObject debugObj;
+
+    this(SharedObject self) {
+        this.self = self;
+        this.debugObj = self; 
+
+        if (!self.hasSection("__DWARF", "__debug_line")) {
+            auto dsymPath = getDsymDefaultPath();
+            this.debugObj = SharedObject.fromFile(dsymPath.ptr);
+        }
+    }
 
-    static Image openSelf()
-    {
-        return Image(_NSGetMachExecuteHeader());
+    T processDebugLineSectionData(T)(scope T delegate(const(ubyte)[]) processor) {
+        return processor(debugObj.getSection("__DWARF", "__debug_line"));
     }
 
-    @property bool isValid()
-    {
-        return self !is null;
+    static Image openSelf() {
+        return Image(SharedObject.thisExecutable());
     }
 
-    T processDebugLineSectionData(T)(scope T delegate(const(ubyte)[]) processor)
-    {
-        c_ulong size;
-        auto data = getsectiondata(self, "__DWARF", "__debug_line", &size);
-        return processor(data[0 .. size]);
+    @property bool isValid() {
+        return self.isValid;
     }
 
-    @property size_t baseAddress()
-    {
-        return 0;
+    @property size_t baseAddress() {
+        return cast(size_t)self.baseAddress;
     }
 }

runtime/druntime/src/core/internal/macho/dl.d

@@ -0,0 +1,228 @@
+/**
+ * Simplifies working with shared Macho-O objects of the current process.
+ *
+ * Copyright: Copyright Kitsunebi Games 2025
+ * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
+ * Authors:   Luna (the Foxgirl) Nielsen
+ * Source: $(DRUNTIMESRC core/internal/macho/dl.d)
+ */
+
+module core.internal.macho.dl;
+
+version (OSX)
+    version = Darwin;
+else version (iOS)
+    version = Darwin;
+else version (TVOS)
+    version = Darwin;
+else version (WatchOS)
+    version = Darwin;
+
+version (Darwin):
+
+import core.sys.darwin.mach.getsect : mach_header_64, getsectiondata, getsectbynamefromheader_64;
+import core.sys.darwin.dlfcn;
+import core.sys.darwin.fcntl;
+import core.sys.darwin.sys.mman;
+import core.sys.posix.sys.stat;
+import core.sys.darwin.mach.loader;
+import core.sys.darwin.mach.dyld : 
+    _dyld_image_count, 
+    _dyld_get_image_name, 
+    _dyld_get_image_header, 
+    _dyld_get_image_vmaddr_slide;
+
+/**
+    Enables iterating over the process' currently loaded shared objects.
+*/
+struct SharedObjects {
+@nogc nothrow:
+    ///
+    alias Callback = int delegate(SharedObject);
+
+    ///
+    static int opApply(scope Callback dg)
+    {
+        foreach(i; 0.._dyld_image_count) {
+            if (int result = dg(SharedObject.fromIndex(i)))
+                return result;
+        }
+        return 0;
+    }
+}
+
+/**
+    A loeaded mach-o binary.
+*/
+struct SharedObject {
+@nogc nothrow:
+private:
+    mach_header_64* _header;
+    ptrdiff_t vmaddr_slide;
+    const(char)* _name;
+
+public:
+
+    /**
+        Returns the shared object with the given index.
+    */
+    static SharedObject fromIndex(uint idx) {
+        return SharedObject(
+            cast(mach_header_64*)_dyld_get_image_header(idx),
+            _dyld_get_image_vmaddr_slide(idx),
+            _dyld_get_image_name(idx)
+        );
+    }
+
+    /**
+        Returns the shared object with the given dlopen handle.
+
+        Params:
+            dlhandle = Handle returned by dlopen
+        
+        Returns:
+            A SharedObject instance matching the given dlhandle,
+            or an empty handle on failure.
+    */
+    static SharedObject fromHandle(void* dlhandle) {
+        foreach(so; SharedObjects) {
+            if (auto hndl = dlopen(so.name, RTLD_NOLOAD)) {
+                dlclose(hndl);
+
+                if (hndl is dlhandle)
+                    return so;
+            }
+        }
+        return SharedObject.init;
+    }
+
+    /**
+        Returns the shared object with the given dlopen handle.
+
+        Params:
+            path = Path to the object to load.
+        
+        Returns:
+            A SharedObject instance matching the given path,
+            or an empty handle on failure.
+    */
+    static SharedObject fromFile(const(char)* path) {
+        if (auto hndl = dlopen(path, 0))
+            return SharedObject.fromHandle(hndl);
+
+        mach_header_64* base_header = cast(mach_header_64*)_dyld_get_image_header(0);
+
+        // Try opening and mapping the file.
+        int fd = open(path, O_RDONLY);
+        if (fd == -1)
+            return SharedObject.init;
+        
+        stat_t fdInfo;
+        if (fstat(fd, &fdInfo) == -1)
+            return SharedObject.init;
+        
+        void* data = mmap(null, fdInfo.st_size, PROT_READ, MAP_SHARED, fd, 0);
+        if (data == MAP_FAILED)
+            return SharedObject.init;
+
+        // Non-fat mach-o object.
+        mach_header* hdr = cast(mach_header*)data;
+        if (hdr.magic == MH_MAGIC || hdr.magic == MH_MAGIC_64) {
+            if (hdr.cputype != base_header.cputype || hdr.cpusubtype != base_header.cpusubtype) {
+                munmap(data, fdInfo.st_size);
+                return SharedObject.init;
+            }
+
+            return SharedObject(cast(mach_header_64*)data, -1, path);
+        }
+
+        // Fat binary.
+        fat_header* fat = cast(fat_header*)data;
+        if (fat.magic == [0xca, 0xfe, 0xba, 0xbe]) {
+            fat_entry* entry = cast(fat_entry*)(data+fat_header.sizeof);
+            foreach(i; 0..fat.count) {
+                if (entry.cputype == base_header.cputype && entry.cpusubtype == base_header.cpusubtype) {
+                    return SharedObject(cast(mach_header_64*)(data+entry.file_offset), -1, path);
+                }
+
+                entry++;
+            }
+        }
+
+        // Remember to unmap the file.
+        munmap(data, fdInfo.st_size);
+        return SharedObject.init;
+    }
+
+    /**
+        Returns the object of the current process' executable.
+    */
+    static SharedObject thisExecutable() {
+        return SharedObject.fromIndex(0);
+    }
+
+    /**
+        Whether the object is valid.
+    */
+    @property bool isValid() {
+        return _header !is null;
+    }
+
+    /**
+        The name of this object.
+    */
+    @property const(char)* name() {
+        return _name;
+    }
+
+    /**
+        The base address of this object.
+    */
+    @property void* baseAddress() {
+        return cast(void*)_header;
+    }
+
+    /**
+        The mach header of the image.
+    */
+    @property mach_header_64* header() {
+        return _header;
+    }
+
+    /**
+        The virtual memory slide for the image.
+    */
+    @property ptrdiff_t slide() {
+        return vmaddr_slide;
+    }
+
+    /**
+        Gets whether the given section is present.
+    */
+    bool hasSection(const(char)* segname, const(char)* sectname) {
+        return getSection(segname, sectname).length > 0;
+    }
+
+    /**
+        Gets the given section within the shared object/image.
+    */
+    ubyte[] getSection(const(char)* segname, const(char)* sectname) {
+
+        // mmapped mach-o
+        if (vmaddr_slide == -1 && _header) {
+            if (auto sect = getsectbynamefromheader_64(_header, segname, sectname)) {
+                return (cast(ubyte*)_header+sect.offset)[0..sect.size];
+            }
+            return null;
+        }
+
+        // linked mach-o
+        if (_header) {
+            size_t len;
+            if (auto data = getsectiondata(_header, segname, sectname, &len))
+                return data[0..len];
+        }
+
+        return null;
+    }
+}