SymbolResolverResolve

Documentation

API Reference

Description

Resolve a runtime instruction pointer to a symbol.

Parameters

Name	Direction	Description
`self`	in,out	Resolver. The cache may grow on this call.
`runtime_addr`	in	Address to resolve, as captured at runtime.
`out`	out	Populated on success. Untouched on failure.

Success

Returns true. out->module_path is set; out->symbol_name may still be NULL if the address falls in a module range that lacks symbol coverage there.

Failure

Returns false if no loaded module contains runtime_addr, or if the resolver fails to open the backing ELF file.

Usage example (Cross-references)

Usage examples (Cross-references)

In SymbolResolver.c:343:

    // ---------------------------------------------------------------------------
    
    bool SymbolResolverResolve(SymbolResolver *self, void *runtime_addr, ResolvedSymbol *out) {
        if (!self || !out)
            return false;

In Backtrace.c:485:

        for (size i = 0; i < count; ++i) {
            ResolvedSymbol r;
            if (SymbolResolverResolve(resolver, frames[i].ip, &r)) {
                emit_resolved_line(out, (u32)i, &r, frames[i].ip);
            } else {

In SymbolResolver.c:77:

    
    static bool resolve_addr(SymbolResolver *res, void *addr, ResolvedSymbol *out) {
        return SymbolResolverResolve(res, addr, out);
    }

In SymbolResolver.c:324:

        ResolvedSymbol r;
        // Page-zero-ish address that no module maps.
        bool ok = !SymbolResolverResolve(&res, (void *)(u64)0x1000, &r);
    
        SymbolResolverDeinit(&res);

In SymbolResolver.c:341:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&test_symres_resolve_self, &r);
        ok                = ok && r.module_path && r.module_path[0] != '\0';
        // We're a function so a symbol should resolve. Name may or may

In SymbolResolver.c:365:

        // .symtab. libc dladdr would fail to name this; we should not.
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&symres_marker_helper, &r);
        ok                = ok && r.symbol_name != NULL && ZstrFindSubstring(r.symbol_name, "symres_marker_helper") != NULL;

In SymbolResolver.c:421:

    
        ResolvedSymbol ra;
        bool           ok    = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &ra) && ra.module_path;
        size           live1 = DebugAllocatorLiveCount(&alloc);

In SymbolResolver.c:425:

    
        ResolvedSymbol rb;
        ok         = ok && SymbolResolverResolve(&res, (void *)&sr1_marker_b, &rb) && rb.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);

In SymbolResolver.c:449:

    
        ResolvedSymbol rc;
        bool           ok    = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &rc) && rc.module_path;
        size           live1 = DebugAllocatorLiveCount(&alloc);

In SymbolResolver.c:453:

    
        ResolvedSymbol rd;
        ok         = ok && SymbolResolverResolve(&res, (void *)&sr_cache_data_marker, &rd) && rd.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);

In SymbolResolver.c:476:

    
        ResolvedSymbol ra;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &ra) && ra.module_path;
    
        u64 other  = 0;

In SymbolResolver.c:483:

    
        ResolvedSymbol ro;
        ok         = ok && SymbolResolverResolve(&res, (void *)other, &ro) && ro.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);

In SymbolResolver.c:505:

    
        ResolvedSymbol ra;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &ra) && ra.module_path;
    
        u64 other = 0;

In SymbolResolver.c:511:

    
        ResolvedSymbol r1;
        ok         = ok && SymbolResolverResolve(&res, (void *)other, &r1) && r1.module_path;
        size live1 = DebugAllocatorLiveCount(&alloc);

In SymbolResolver.c:515:

    
        ResolvedSymbol r2;
        ok         = ok && SymbolResolverResolve(&res, (void *)other, &r2) && r2.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);

In SymbolResolver.c:538:

        }
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &r);
    
        SymbolResolverDeinit(&res);

In SymbolResolver.c:563:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr_notype_marker, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "sr_notype_marker") != NULL;
        // size-0 symbol: it matched at its exact value, so the offset is zero.

In SymbolResolver.c:584:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr_cache_data_marker, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "sr_cache_data_marker") != NULL;

In SymbolResolver.c:604:

    
        ResolvedSymbol r0;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &r0);
        ok                = ok && r0.symbol_name && r0.symbol_size > 0;
        if (ok) {

In SymbolResolver.c:609:

            u64            base = (u64)(void *)&sr1_marker_a;
            ResolvedSymbol re;
            if (SymbolResolverResolve(&res, (void *)(base + r0.symbol_size), &re)) {
                // The one-past-end address must not land back inside marker_a:
                // either no name, or a different enclosing symbol.

In SymbolResolver.c:635:

    
        ResolvedSymbol ra;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &ra) && ra.module_path;
    
        u64 other = 0;

In SymbolResolver.c:641:

    
        ResolvedSymbol ro;
        ok = ok && SymbolResolverResolve(&res, (void *)other, &ro) && ro.module_path;
        ok = ok && ZstrCompare(ra.module_path, ro.module_path) != 0; // two distinct cache entries

In SymbolResolver.c:667:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr1_marker_a, &r) && r.module_base != 0;
    
        const DwarfCfi *cfi  = NULL;

In SymBind.c:59:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr_bind_global_sized, &r);
        ok                = ok && r.symbol_name != NULL;
        ok                = ok && ZstrFindSubstring(r.symbol_name, "sr_bind_global_sized") != NULL;

In SymBind.c:79:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sr_bind_global_zero, &r);
        ok                = ok && r.symbol_name != NULL;
        ok                = ok && ZstrFindSubstring(r.symbol_name, "sr_bind_global_zero") != NULL;

In SidecarDwarf.c:43:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&scd_marker, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "scd_marker") != NULL;

In SidecarDwarf.c:65:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&scd_marker, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "scd_marker") != NULL;
        ok                = ok && DebugAllocatorLiveCount(&alloc) > baseline;

In SidecarSub.c:44:

        u64            addr = (u64)(void *)&subdir_marker;
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)addr, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "subdir_marker") != NULL;
        ok                = ok && r.offset == 0;

In SidecarSub.c:68:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&subdir_marker, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "subdir_marker") != NULL;
        ok                = ok && DebugAllocatorLiveCount(&alloc) > baseline;

In Sidecar.c:45:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sidecar_marker, &r);
        ok                = ok && r.module_path && r.module_path[0] != '\0';
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "sidecar_marker") != NULL;

In Sidecar.c:81:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&sidecar_marker, &r);
        // The marker is named only via the opened sidecar, proving the cache
        // entry actually carries one.

In DwarfFallback.c:53:

        u64            addr = (u64)(void *)&df_marker_a;
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)addr, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "df_marker_a") != NULL;
        // Entry address: offset 0, reconstruction holds against the DWARF-sourced

In DwarfFallback.c:66:

        if (ok) {
            ResolvedSymbol rlast;
            ok = SymbolResolverResolve(&res, (void *)(addr + r.symbol_size - 1), &rlast);
            ok = ok && rlast.symbol_name && ZstrFindSubstring(rlast.symbol_name, "df_marker_a") != NULL;
            ok = ok && rlast.symbol_value == r.symbol_value;

In DwarfFallback.c:90:

        u64            base = (u64)(void *)&df_marker_a;
        ResolvedSymbol r0, rk;
        bool           ok = SymbolResolverResolve(&res, (void *)base, &r0);
        ok                = ok && r0.symbol_name && r0.symbol_size > 4;
        if (ok) {

In DwarfFallback.c:93:

        ok                = ok && r0.symbol_name && r0.symbol_size > 4;
        if (ok) {
            ok = SymbolResolverResolve(&res, (void *)(base + 4), &rk);
            ok = ok && rk.symbol_name && rk.symbol_value == r0.symbol_value;
            ok = ok && rk.offset == 4;

In DwarfFallback.c:117:

    
        ResolvedSymbol ra, rb;
        bool           ok = SymbolResolverResolve(&res, (void *)&df_marker_a, &ra);
        ok                = ok && SymbolResolverResolve(&res, (void *)&df_marker_b, &rb);
        ok                = ok && ra.source_file && ZstrFindSubstring(ra.source_file, "DwarfFallback.c") != NULL;

In DwarfFallback.c:118:

        ResolvedSymbol ra, rb;
        bool           ok = SymbolResolverResolve(&res, (void *)&df_marker_a, &ra);
        ok                = ok && SymbolResolverResolve(&res, (void *)&df_marker_b, &rb);
        ok                = ok && ra.source_file && ZstrFindSubstring(ra.source_file, "DwarfFallback.c") != NULL;
        ok                = ok && rb.source_file && ZstrFindSubstring(rb.source_file, "DwarfFallback.c") != NULL;

In DwarfFallback.c:145:

    
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, (void *)&df_marker_a, &r);
        // The name came from DWARF, proving the function table was built (and the
        // line table alongside it).

In Bias.c:65:

        void          *addr = symres_bias_data_addr();
        ResolvedSymbol r;
        bool           ok = SymbolResolverResolve(&res, addr, &r);
        ok                = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "symres_bias_data") != NULL;
        ok                = ok && r.offset == 0;

In Bias.c:89:

        const u64      K    = 8;
        ResolvedSymbol r0, rk;
        bool           ok = SymbolResolverResolve(&res, (void *)base, &r0);
        ok                = ok && SymbolResolverResolve(&res, (void *)(base + K), &rk);
        ok                = ok && r0.symbol_name && rk.symbol_name;

In Bias.c:90:

        ResolvedSymbol r0, rk;
        bool           ok = SymbolResolverResolve(&res, (void *)base, &r0);
        ok                = ok && SymbolResolverResolve(&res, (void *)(base + K), &rk);
        ok                = ok && r0.symbol_name && rk.symbol_name;
        ok                = ok && ZstrFindSubstring(rk.symbol_name, "symres_bias_data") != NULL;

In Bias.c:117:

        void          *data = symres_bias_data_addr();
        ResolvedSymbol r0;
        bool           ok = SymbolResolverResolve(&res, data, &r0) && r0.module_path && r0.symbol_size > 0;
    
        u64 ms = 0, mfo = 0;

In Bias.c:125:

            u64            uncovered = (u64)data + r0.symbol_size + 8;
            ResolvedSymbol rf;
            ok = SymbolResolverResolve(&res, (void *)uncovered, &rf);
            ok = ok && rf.module_base == ms - mfo;
        }

In Bias.c:148:

        void          *data = symres_bias_data_addr();
        ResolvedSymbol r0;
        bool           ok = SymbolResolverResolve(&res, data, &r0) && r0.module_path && r0.symbol_size > 0;
    
        u64 ms = 0, mfo = 0;

In Bias.c:155:

            u64            past = (u64)data + r0.symbol_size;
            ResolvedSymbol re;
            ok = SymbolResolverResolve(&res, (void *)past, &re);
            ok = ok && re.module_base == ms - mfo;       // fallback base, segment excluded
            ok = ok && re.module_base != r0.module_base; // distinct from the in-segment base

In Stripped.c:52:

        }
        ResolvedSymbol r;
        if (!SymbolResolverResolve(&res, (void *)func, &r)) {
            SymbolResolverDeinit(&res);
            DefaultAllocatorDeinit(&alloc);

In Dwarf.c:55:

    
        ResolvedSymbol r;
        if (!SymbolResolverResolve(&res, (void *)&dwarf_marker_helper, &r)) {
            SymbolResolverDeinit(&res);
            DefaultAllocatorDeinit(&alloc);

In Dwarf.c:101:

    
        ResolvedSymbol r;
        if (!SymbolResolverResolve(&res, (void *)&dwarf_marker_helper, &r)) {
            SymbolResolverDeinit(&res);
            DefaultAllocatorDeinit(&alloc);

In Dwarf.c:164:

    
        ResolvedSymbol r;
        if (!SymbolResolverResolve(&res, (void *)&dwarf_marker_helper, &r)) {
            SymbolResolverDeinit(&res);
            DefaultAllocatorDeinit(&alloc);

Last updated on July 1, 2026

SymbolResolverInit TestFunction