Function dump_alloc_leaks

src/misc/alloc_tracker.cpp:353–491

}

size_t dump_alloc_leaks(FILE *out) {
    // Disarm so fprintf/Sym*/etc don't churn the map during the dump.
    bool was_armed = g_armed.exchange(false);
    (void)was_armed;
    tl_inside = true;

    auto t0 = std::chrono::steady_clock::now();

    // Snapshot under lock; std::malloc keeps storage out of the tracker.
    Group *groups = nullptr;
    size_t groupCount = 0;
    size_t groupCap   = 0;
    size_t totalLeaks = 0;
    size_t totalBytes = 0;
    size_t largestSingle = 0;
    bool   groupsExhausted = false;

    {
        std::lock_guard<std::mutex> lock(getMutex());
        LeakMap &m = getMap();
        for (size_t i = 0; i < m.capacity; ++i) {
            void *k = m.entries[i].key;
            if (k == nullptr || k == kTombstone) continue;
            const AllocInfo &info = m.entries[i].info;
            ++totalLeaks;
            totalBytes += info.size;
            if (info.size > largestSingle) largestSingle = info.size;

            if (groupsExhausted) continue;

            uint64_t h = hash_frames(info.frames, info.frameCount);

            Group *g = nullptr;
            for (size_t j = 0; j < groupCount; ++j) {
                if (groups[j].hash == h) { g = &groups[j]; break; }
            }
            if (!g) {
                if (groupCount == groupCap) {
                    size_t newCap = groupCap ? groupCap * 2 : 64;
                    Group *resized = (Group*)std::realloc(groups, newCap * sizeof(Group));
                    if (!resized) {
                        // OOM mid-shutdown: keep counting totals, drop new sites.
                        groupsExhausted = true;
                        continue;
                    }
                    groups   = resized;
                    groupCap = newCap;
                }
                g = &groups[groupCount++];
                g->hash       = h;
                g->count      = 0;
                g->totalBytes = 0;
                g->minSize    = SIZE_MAX;
                g->maxSize    = 0;
                g->samplePtr  = k;
                g->frameCount = info.frameCount;
                memcpy(g->frames, info.frames, info.frameCount * sizeof(void*));
            }