Skip to content

std.debug.SelfInfo.Elf

Standard libraryZig 0.17.0Official documentation
Sourcestd/debug/SelfInfo/Elf.zig

Source line 1

Fields

rwlock: Io.RwLock
modules: std.ArrayList(Module)
ranges: std.ArrayList(Module.Range)
unwind_cache: if (can_unwind) ?[]Dwarf.SelfUnwinder.CacheEntry else ?noreturn

std.debug.SelfInfo.Elf.Allocator

alias

Source line 531

Alias of std.mem.Allocator

std.debug.SelfInfo.Elf.assert

alias

Source line 534

Alias of std.debug.assert

std.debug.SelfInfo.Elf.builtin

constant

Source line 536

std.debug.SelfInfo.Elf.can_unwind

constant

Source line 117

bool

std.debug.SelfInfo.Elf.deinit

function

Source line 14

pub fn deinit(si: *SelfInfo, io: Io) void

Parameters

si: *SelfInfo
io: Io

std.debug.SelfInfo.Elf.DlIterContext

container

Source line 469

Fields

si: *SelfInfo
gpa: Allocator

std.debug.SelfInfo.Elf.DlIterContext.callback

function

Source line 473

fn callback(info: *std.posix.dl_phdr_info, size: usize, context: *@This()) !void

Parameters

info: *std.posix.dl_phdr_info
size: usize
context: *@This()

std.debug.SelfInfo.Elf.Dwarf

alias

Source line 532

Alias of std.debug.Dwarf

std.debug.SelfInfo.Elf.Error

alias

Source line 533

Alias of std.debug.SelfInfoError

std.debug.SelfInfo.Elf.findModule

function

Source line 407

fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum { shared, exclusive }) Error!*Module

Parameters

si: *SelfInfo
gpa: Allocator
io: Io
address: usize
lock: enum { shared, exclusive }

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.getModuleName

function

Source line 103

pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8

Parameters

si: *SelfInfo
io: Io
address: usize

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.getModuleSlide

function

Source line 110

pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize

Parameters

si: *SelfInfo
io: Io
address: usize

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.getSymbols

function

Source line 33

pub fn getSymbols( si: *SelfInfo, io: Io, symbol_allocator: Allocator, text_arena: Allocator, address: usize, resolve_inline_callers: bool, symbols: *std.ArrayList(std.debug.Symbol), ) Error!void

Parameters

si: *SelfInfo
io: Io
symbol_allocator: Allocator
text_arena: Allocator
address: usize
resolve_inline_callers: bool
symbols: *std.ArrayList(std.debug.Symbol)

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.init

constant

Source line 8

SelfInfo

std.debug.SelfInfo.Elf.Io

alias

Source line 530

Alias of std.Io

std.debug.SelfInfo.Elf.Module

container

Source line 263

Fields

load_offset: usize
name: []const u8
build_id: ?[]const u8
gnu_eh_frame: ?[]const u8
unwind: ?(Error!UnwindSections)

null means unwind information has not yet been loaded.

loaded_elf: ?(Error!LoadedElf)

null means the ELF file has not yet been loaded.

std.debug.SelfInfo.Elf.Module.getLoadedElf

function

Source line 350

Assumes we already hold an exclusive lock.

fn getLoadedElf(mod: *Module, gpa: Allocator, io: Io) Error!*LoadedElf

Parameters

mod: *Module
gpa: Allocator
io: Io

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.Module.getUnwindSections

function

Source line 293

Assumes we already hold an exclusive lock.

fn getUnwindSections(mod: *Module, gpa: Allocator, io: Io) Error![]Dwarf.Unwind

Parameters

mod: *Module
gpa: Allocator
io: Io

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.Module.LoadedElf

container

Source line 275

Fields

file: std.debug.ElfFile
dwarf: enum { not_scanned, invalid, missing, ok }

std.debug.SelfInfo.Elf.Module.loadElf

function

Source line 355

fn loadElf(mod: *Module, gpa: Allocator, io: Io) Error!LoadedElf

Parameters

mod: *Module
gpa: Allocator
io: Io

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.Module.loadUnwindSections

function

Source line 298

fn loadUnwindSections(mod: *Module, gpa: Allocator, io: Io) Error!UnwindSections

Parameters

mod: *Module
gpa: Allocator
io: Io

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

std.debug.SelfInfo.Elf.Module.Range

container

Source line 285

Fields

start: usize
len: usize
module_index: usize

Index into modules

std.debug.SelfInfo.Elf.Module.UnwindSections

container

Source line 280

Fields

buf: [2]Dwarf.Unwind
len: usize

std.debug.SelfInfo.Elf.native_endian

constant

Source line 537

std.debug.SelfInfo.Elf.SelfInfo

alias

Source line 539

Alias of std.debug.SelfInfo.Elf

std.debug.SelfInfo.Elf.std

alias

Source line 529

Alias of std

std.debug.SelfInfo.Elf.UnwindContext

alias

Source line 210

Alias of std.debug.Dwarf.SelfUnwinder

std.debug.SelfInfo.Elf.unwindFrame

function

Source line 211

pub fn unwindFrame(si: *SelfInfo, io: Io, context: *UnwindContext) Error!usize

Parameters

si: *SelfInfo
io: Io
context: *UnwindContext

Errors

Canceled SelfInfoError
InvalidDebugInfo SelfInfoError

The required debug info is invalid or corrupted.

MissingDebugInfo SelfInfoError

The required debug info could not be found.

OutOfMemory SelfInfoError
ReadFailed SelfInfoError

The required debug info could not be read from disk due to some IO error.

Unexpected SelfInfoError
UnsupportedDebugInfo SelfInfoError

The required debug info was found, and may be valid, but is not supported by this implementation.

Source code

std/debug/SelfInfo/Elf.zig

rwlock: Io.RwLock,

modules: std.ArrayList(Module),
ranges: std.ArrayList(Module.Range),

unwind_cache: if (can_unwind) ?[]Dwarf.SelfUnwinder.CacheEntry else ?noreturn,

pub const init: SelfInfo = .{
    .rwlock = .init,
    .modules = .empty,
    .ranges = .empty,
    .unwind_cache = null,
};
pub fn deinit(si: *SelfInfo, io: Io) void {
    _ = io;
    const gpa = std.debug.getDebugInfoAllocator();
    for (si.modules.items) |*mod| {
        unwind: {
            const u = &(mod.unwind orelse break :unwind catch break :unwind);
            for (u.buf[0..u.len]) |*unwind| unwind.deinit(gpa);
        }
        loaded: {
            const l = &(mod.loaded_elf orelse break :loaded catch break :loaded);
            l.file.deinit(gpa);
        }
    }

    si.modules.deinit(gpa);
    si.ranges.deinit(gpa);
    if (si.unwind_cache) |cache| gpa.free(cache);
}

pub fn getSymbols(
    si: *SelfInfo,
    io: Io,
    symbol_allocator: Allocator,
    text_arena: Allocator,
    address: usize,
    resolve_inline_callers: bool,
    symbols: *std.ArrayList(std.debug.Symbol),
) Error!void {
    const gpa = std.debug.getDebugInfoAllocator();
    const module = try si.findModule(gpa, io, address, .exclusive);
    defer si.rwlock.unlock(io);

    const vaddr = address - module.load_offset;

    const loaded_elf = try module.getLoadedElf(gpa, io);
    const dwarf_err: ?Error = err: {
        const dwarf = &(loaded_elf.file.dwarf orelse break :err null);
        switch (loaded_elf.dwarf) {
            .not_scanned => if (dwarf.open(gpa, native_endian)) {
                loaded_elf.dwarf = .ok;
            } else |err| switch (err) {
                error.InvalidDebugInfo,
                error.EndOfStream,
                error.Overflow,
                error.ReadFailed,
                error.StreamTooLong,
                => {
                    loaded_elf.dwarf = .invalid;
                    break :err error.InvalidDebugInfo;
                },
                error.MissingDebugInfo => {
                    loaded_elf.dwarf = .missing;
                    break :err error.MissingDebugInfo;
                },
                error.OutOfMemory => |e| return e,
            },
            .invalid => break :err error.InvalidDebugInfo,
            .missing => break :err error.MissingDebugInfo,
            .ok => {},
        }
        return dwarf.getSymbols(
            symbol_allocator,
            text_arena,
            native_endian,
            vaddr,
            resolve_inline_callers,
            symbols,
        ) catch |err| switch (err) {
            error.InvalidDebugInfo,
            error.MissingDebugInfo,
            error.UnsupportedDebugInfo,
            => |e| break :err e,

            error.ReadFailed,
            error.OutOfMemory,
            error.Canceled,
            error.Unexpected,
            => |e| return e,
        };
    };
    // When DWARF is unavailable, fall back to searching the symtab.
    try symbols.append(symbol_allocator, loaded_elf.file.searchSymtab(gpa, vaddr) catch |err| switch (err) {
        error.NoSymtab, error.NoStrtab => return error.MissingDebugInfo,
        error.BadSymtab => return error.InvalidDebugInfo,
        error.OutOfMemory => |e| return e,
    });
    // After searching the symtab, still report the DWARF error.
    if (dwarf_err) |e| return e;
}
pub fn getModuleName(si: *SelfInfo, io: Io, address: usize) Error![]const u8 {
    const gpa = std.debug.getDebugInfoAllocator();
    const module = try si.findModule(gpa, io, address, .shared);
    defer si.rwlock.unlockShared(io);
    if (module.name.len == 0) return error.MissingDebugInfo;
    return module.name;
}
pub fn getModuleSlide(si: *SelfInfo, io: Io, address: usize) Error!usize {
    const gpa = std.debug.getDebugInfoAllocator();
    const module = try si.findModule(gpa, io, address, .shared);
    defer si.rwlock.unlockShared(io);
    return module.load_offset;
}

pub const can_unwind: bool = s: {
    const archs: []const std.Target.Cpu.Arch = switch (builtin.target.os.tag) {
        .haiku => &.{
            .aarch64,
            .arm,
            .riscv64,
            .x86,
            .x86_64,
        },
        .illumos => &.{
            .x86,
            .x86_64,
        },
        // Not supported yet: hppa, hppa64, microblaze/microblazeel, sh/sheb
        .linux => &.{
            .aarch64,
            .aarch64_be,
            .alpha,
            .arc,
            .arm,
            .armeb,
            .csky,
            .loongarch32,
            .loongarch64,
            .m68k,
            .mips,
            .mipsel,
            .mips64,
            .mips64el,
            .or1k,
            .riscv32,
            .riscv64,
            .s390x,
            .thumb,
            .thumbeb,
            .x86,
            .x86_64,
        },
        .serenity => &.{
            .aarch64,
            .x86_64,
            .riscv64,
        },

        .dragonfly => &.{
            .x86_64,
        },
        .freebsd => &.{
            .aarch64,
            .arm,
            .riscv64,
            .x86,
            .x86_64,
        },
        // Not supported yet: hppa, mips64/mips64el, sh/sheb
        .netbsd => &.{
            .aarch64,
            .aarch64_be,
            .alpha,
            .arm,
            .armeb,
            .m68k,
            .mips,
            .mipsel,
            .riscv32,
            .riscv64,
            .x86,
            .x86_64,
        },
        // Not supported yet: hppa, sh
        .openbsd => &.{
            .aarch64,
            .arm,
            .m88k,
            .mips64,
            .mips64el,
            .riscv64,
            .x86,
            .x86_64,
        },

        else => unreachable,
    };
    for (archs) |a| {
        if (builtin.target.cpu.arch == a) break :s true;
    }
    break :s false;
};
comptime {
    if (can_unwind) {
        std.debug.assert(Dwarf.supportsUnwinding(&builtin.target));
    }
}
pub const UnwindContext = Dwarf.SelfUnwinder;
pub fn unwindFrame(si: *SelfInfo, io: Io, context: *UnwindContext) Error!usize {
    comptime assert(can_unwind);
    const gpa = std.debug.getDebugInfoAllocator();

    {
        si.rwlock.lockSharedUncancelable(io);
        defer si.rwlock.unlockShared(io);
        if (si.unwind_cache) |cache| {
            if (Dwarf.SelfUnwinder.CacheEntry.find(cache, context.pc)) |entry| {
                return context.next(gpa, entry);
            }
        }
    }

    const module = try si.findModule(gpa, io, context.pc, .exclusive);
    defer si.rwlock.unlock(io);

    if (si.unwind_cache == null) {
        si.unwind_cache = try gpa.alloc(Dwarf.SelfUnwinder.CacheEntry, 2048);
        @memset(si.unwind_cache.?, .empty);
    }

    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.?);
            return context.next(gpa, &entry);
        } else |err| switch (err) {
            error.MissingDebugInfo => continue,

            error.InvalidDebugInfo,
            error.UnsupportedDebugInfo,
            error.OutOfMemory,
            => |e| return e,

            error.EndOfStream,
            error.StreamTooLong,
            error.ReadFailed,
            error.Overflow,
            error.InvalidOpcode,
            error.InvalidOperation,
            error.InvalidOperand,
            => return error.InvalidDebugInfo,

            error.UnimplementedUserOpcode,
            error.UnsupportedAddrSize,
            => return error.UnsupportedDebugInfo,
        }
    }
    return error.MissingDebugInfo;
}

const Module = struct {
    load_offset: usize,
    name: []const u8,
    build_id: ?[]const u8,
    gnu_eh_frame: ?[]const u8,

    /// `null` means unwind information has not yet been loaded.
    unwind: ?(Error!UnwindSections),

    /// `null` means the ELF file has not yet been loaded.
    loaded_elf: ?(Error!LoadedElf),

    const LoadedElf = struct {
        file: std.debug.ElfFile,
        dwarf: enum { not_scanned, invalid, missing, ok },
    };

    const UnwindSections = struct {
        buf: [2]Dwarf.Unwind,
        len: usize,
    };

    const Range = struct {
        start: usize,
        len: usize,
        /// Index into `modules`
        module_index: usize,
    };

    /// Assumes we already hold an exclusive lock.
    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, io: Io) Error!UnwindSections {
        var us: UnwindSections = .{
            .buf = undefined,
            .len = 0,
        };
        if (mod.gnu_eh_frame) |section_bytes| {
            const section_vaddr: u64 = @intFromPtr(section_bytes.ptr) - mod.load_offset;
            const header = Dwarf.Unwind.EhFrameHeader.parse(section_vaddr, section_bytes, @sizeOf(usize), native_endian) catch |err| switch (err) {
                error.ReadFailed => unreachable, // it's all fixed buffers
                error.InvalidDebugInfo => |e| return e,
                error.EndOfStream, error.Overflow => return error.InvalidDebugInfo,
                error.UnsupportedAddrSize => return error.UnsupportedDebugInfo,
            };
            us.buf[us.len] = .initEhFrameHdr(header, section_vaddr, @ptrFromInt(@as(usize, @intCast(mod.load_offset + header.eh_frame_vaddr))));
            us.len += 1;
        } 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, 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| {
                us.buf[us.len] = .initSection(.debug_frame, debug_frame.vaddr, debug_frame.bytes);
                us.len += 1;
            }
            if (loaded.file.eh_frame) |*eh_frame| {
                us.buf[us.len] = .initSection(.eh_frame, eh_frame.vaddr, eh_frame.bytes);
                us.len += 1;
            }
        }
        errdefer for (us.buf[0..us.len]) |*u| u.deinit(gpa);
        for (us.buf[0..us.len]) |*u| u.prepare(gpa, @sizeOf(usize), native_endian, true, false) catch |err| switch (err) {
            error.ReadFailed => unreachable, // it's all fixed buffers
            error.InvalidDebugInfo,
            error.MissingDebugInfo,
            error.OutOfMemory,
            => |e| return e,
            error.EndOfStream,
            error.Overflow,
            error.StreamTooLong,
            error.InvalidOperand,
            error.InvalidOpcode,
            error.InvalidOperation,
            => return error.InvalidDebugInfo,
            error.UnsupportedAddrSize,
            error.UnimplementedUserOpcode,
            => return error.UnsupportedDebugInfo,
        };
        return us;
    }

    /// Assumes we already hold an exclusive lock.
    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, io: Io) Error!LoadedElf {
        const load_result = if (mod.name.len > 0) res: {
            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.process.executablePathAlloc(io, gpa) catch |err| switch (err) {
                error.OutOfMemory => |e| return e,
                else => return error.ReadFailed,
            };
            defer gpa.free(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) {
            error.OutOfMemory,
            error.Unexpected,
            error.Canceled,
            => |e| return e,

            error.Overflow,
            error.TruncatedElfFile,
            error.InvalidCompressedSection,
            error.InvalidElfMagic,
            error.InvalidElfVersion,
            error.InvalidElfClass,
            error.InvalidElfEndian,
            => return error.InvalidDebugInfo,

            error.SystemResources,
            error.MemoryMappingNotSupported,
            error.AccessDenied,
            error.LockedMemoryLimitExceeded,
            error.ProcessFdQuotaExceeded,
            error.SystemFdQuotaExceeded,
            error.Streaming,
            => return error.ReadFailed,
        };
        errdefer elf_file.deinit(gpa);

        if (elf_file.endian != native_endian) return error.InvalidDebugInfo;
        if (elf_file.is_64 != (@sizeOf(usize) == 8)) return error.InvalidDebugInfo;

        return .{
            .file = elf_file,
            .dwarf = .not_scanned,
        };
    }
};

fn findModule(si: *SelfInfo, gpa: Allocator, io: Io, address: usize, lock: enum { shared, exclusive }) Error!*Module {
    // With the requested lock, scan the module ranges looking for `address`.
    switch (lock) {
        .shared => si.rwlock.lockSharedUncancelable(io),
        .exclusive => si.rwlock.lockUncancelable(io),
    }
    for (si.ranges.items) |*range| {
        if (address >= range.start and address < range.start + range.len) {
            return &si.modules.items[range.module_index];
        }
    }
    // The address wasn't in a known range. We will rebuild the module/range lists, since it's possible
    // a new module was loaded. Upgrade to an exclusive lock if necessary.
    switch (lock) {
        .shared => {
            si.rwlock.unlockShared(io);
            si.rwlock.lockUncancelable(io);
        },
        .exclusive => {},
    }
    // Rebuild module list with the exclusive lock.
    {
        errdefer si.rwlock.unlock(io);
        if (si.unwind_cache) |cache| {
            @memset(cache, .empty);
        }
        for (si.modules.items) |*mod| {
            unwind: {
                const u = &(mod.unwind orelse break :unwind catch break :unwind);
                for (u.buf[0..u.len]) |*unwind| unwind.deinit(gpa);
            }
            loaded: {
                const l = &(mod.loaded_elf orelse break :loaded catch break :loaded);
                l.file.deinit(gpa);
            }
        }
        si.modules.clearRetainingCapacity();
        si.ranges.clearRetainingCapacity();
        var ctx: DlIterContext = .{ .si = si, .gpa = gpa };
        try std.posix.dl_iterate_phdr(&ctx, error{OutOfMemory}, DlIterContext.callback);
    }
    // Downgrade the lock back to shared if necessary.
    switch (lock) {
        .shared => {
            si.rwlock.unlock(io);
            si.rwlock.lockSharedUncancelable(io);
        },
        .exclusive => {},
    }
    // Scan the newly rebuilt module ranges.
    for (si.ranges.items) |*range| {
        if (address >= range.start and address < range.start + range.len) {
            return &si.modules.items[range.module_index];
        }
    }
    // Still nothing; unlock and error.
    switch (lock) {
        .shared => si.rwlock.unlockShared(io),
        .exclusive => si.rwlock.unlock(io),
    }
    return error.MissingDebugInfo;
}
const DlIterContext = struct {
    si: *SelfInfo,
    gpa: Allocator,

    fn callback(info: *std.posix.dl_phdr_info, size: usize, context: *@This()) !void {
        _ = size;

        var build_id: ?[]const u8 = null;
        var gnu_eh_frame: ?[]const u8 = null;

        // Populate `build_id` and `gnu_eh_frame`
        for (info.phdr[0..info.phnum]) |phdr| {
            switch (phdr.type) {
                .NOTE => {
                    // Look for .note.gnu.build-id
                    const segment_ptr: [*]const u8 = @ptrFromInt(info.addr + phdr.vaddr);
                    var r: std.Io.Reader = .fixed(segment_ptr[0..phdr.memsz]);
                    const name_size = r.takeInt(u32, native_endian) catch continue;
                    const desc_size = r.takeInt(u32, native_endian) catch continue;
                    const note_type = r.takeInt(u32, native_endian) catch continue;
                    const name = r.take(name_size) catch continue;
                    if (note_type != std.elf.NT_GNU_BUILD_ID) continue;
                    if (!std.mem.eql(u8, name, "GNU\x00")) continue;
                    const desc = r.take(desc_size) catch continue;
                    build_id = desc;
                },
                std.elf.PT.GNU_EH_FRAME => {
                    const segment_ptr: [*]const u8 = @ptrFromInt(info.addr + phdr.vaddr);
                    gnu_eh_frame = segment_ptr[0..phdr.memsz];
                },
                else => {},
            }
        }

        const gpa = context.gpa;
        const si = context.si;

        const module_index = si.modules.items.len;
        try si.modules.append(gpa, .{
            .load_offset = info.addr,
            // Android libc uses NULL instead of "" to mark the main program
            .name = std.mem.sliceTo(info.name, 0) orelse "",
            .build_id = build_id,
            .gnu_eh_frame = gnu_eh_frame,
            .unwind = null,
            .loaded_elf = null,
        });

        for (info.phdr[0..info.phnum]) |phdr| {
            if (phdr.type != .LOAD) continue;
            try context.si.ranges.append(gpa, .{
                // Overflowing addition handles VSDOs having vaddr = 0xffffffffff700000
                .start = info.addr +% phdr.vaddr,
                .len = phdr.memsz,
                .module_index = module_index,
            });
        }
    }
};

const std = @import("std");
const Io = std.Io;
const Allocator = std.mem.Allocator;
const Dwarf = std.debug.Dwarf;
const Error = std.debug.SelfInfoError;
const assert = std.debug.assert;

const builtin = @import("builtin");
const native_endian = builtin.target.cpu.arch.endian();

const SelfInfo = @This();