ProcMapsFindByAddr

    
        u64                 addr  = (u64)runtime_addr;
        const ProcMapEntry *entry = ProcMapsFindByAddr(&self->maps, addr);
        if (!entry || !entry->path || entry->path[0] == '\0')
            return false;

        u64 addr = (u64)runtime_addr;
    
        const ProcMapEntry *entry = ProcMapsFindByAddr(&self->maps, addr);
        if (!entry || !entry->path || entry->path[0] == '\0') {
            return false;

    }
    
    const ProcMapEntry *ProcMapsFindByAddr(const ProcMaps *self, u64 addr) {
        if (!self)
            return NULL;

    
        // 0x5500 is inside the stale e2 range only — must be unreachable.
        const ProcMapEntry *hit = ProcMapsFindByAddr(&pm, 0x5500);
        bool                ok  = (hit == NULL);

    
        // Sanity: live entries are still found at the right slots.
        const ProcMapEntry *h0 = ProcMapsFindByAddr(&pm, 0x1500);
        const ProcMapEntry *h1 = ProcMapsFindByAddr(&pm, 0x3500);
        ok                     = ok && h0 != NULL && h0->start == 0x1000 && h1 != NULL && h1->start == 0x3000;

        // Sanity: live entries are still found at the right slots.
        const ProcMapEntry *h0 = ProcMapsFindByAddr(&pm, 0x1500);
        const ProcMapEntry *h1 = ProcMapsFindByAddr(&pm, 0x3500);
        ok                     = ok && h0 != NULL && h0->start == 0x1000 && h1 != NULL && h1->start == 0x3000;

        // mapping of the test binary itself.
        u64                 self_addr = (u64)&test_procmaps_find_self;
        const ProcMapEntry *entry     = ProcMapsFindByAddr(&maps, self_addr);
    
        bool ok = entry != NULL && (entry->perms & PROC_MAP_PERM_EXEC) != 0;

    
        u64                 fn_addr = (u64)&pm2_marker_fn;
        const ProcMapEntry *e       = ProcMapsFindByAddr(&maps, fn_addr);
    
        bool ok = e != NULL;

    
        u64                 stack_addr = (u64)&local;
        const ProcMapEntry *e          = ProcMapsFindByAddr(&maps, stack_addr);
    
        bool ok = e != NULL;

            if (ok) {
                u64                 start = region->start;
                const ProcMapEntry *hit   = ProcMapsFindByAddr(&maps, start);
                // The start address must resolve, and to a region whose
                // start is exactly that address.

            // end - 1 is the last byte inside the region: must resolve to it.
            if (ok) {
                const ProcMapEntry *last_in = ProcMapsFindByAddr(&maps, top->end - 1);
                ok                          = last_in != NULL && last_in->end == top->end;
            }

            // end is one-past the top region and above all mappings: NULL.
            if (ok) {
                const ProcMapEntry *past = ProcMapsFindByAddr(&maps, top->end);
                ok                       = past == NULL;
            }

    
        // Address 0 / a tiny address is never mapped in a normal process.
        const ProcMapEntry *e = ProcMapsFindByAddr(&maps, (u64)0x1);
    
        bool ok = e == NULL;

            if (!inside) {
                found_gap                  = true;
                const ProcMapEntry *at_gap = ProcMapsFindByAddr(&maps, hole);
                ok                         = at_gap == NULL;
            }

        // definitely-unmapped high canonical-hole address.
        if (!found_gap) {
            const ProcMapEntry *at = ProcMapsFindByAddr(&maps, (u64)0x0000800000000000ULL);
            ok                     = at == NULL;
        }