DebugAllocatorLiveCount

Documentation

API Reference

Description

Number of outstanding allocations (alloc minus free), read from the embedded live map.

Parameters

Name	Direction	Description
`self`	in	DebugAllocator instance, or NULL.

Success

Returns the live-allocation count. No state is touched.

Failure

Returns 0 when self is NULL.

Usage example (Cross-references)

Usage examples (Cross-references)

In Debug.c:505:

    // ---------------------------------------------------------------------------
    
    size DebugAllocatorLiveCount(const DebugAllocator *self) {
        if (!self)
            return 0;

In AllocDebug.c:37:

    
        bool ok = p1 && p2;
        ok      = ok && DebugAllocatorLiveCount(&dbg) == 2;
        ok      = ok && DebugAllocatorLiveBytes(&dbg) == (64 + 128);

In AllocDebug.c:41:

    
        AllocatorFree(adbg, p1);
        ok = ok && DebugAllocatorLiveCount(&dbg) == 1;
        ok = ok && DebugAllocatorLiveBytes(&dbg) == 128;

In AllocDebug.c:45:

    
        AllocatorFree(adbg, p2);
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        ok = ok && DebugAllocatorLiveBytes(&dbg) == 0;
        ok = ok && DebugAllocatorOverflows(&dbg) == 0;

In AllocDebug.c:58:

    
        void *p  = AllocatorAlloc(adbg, 0, false);
        bool  ok = (p == NULL) && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In AllocDebug.c:70:

        AllocatorFree(adbg, NULL); // no-op, must not crash
        void *p  = AllocatorAlloc(adbg, 32, false);
        bool  ok = (p != NULL) && (DebugAllocatorLiveCount(&dbg) == 1);
        if (p)
            AllocatorFree(adbg, p);

In AllocDebug.c:104:

        (void)AllocatorAlloc(adbg, 48, true);
    
        bool ok = DebugAllocatorLiveCount(&dbg) == 2;
        ok      = ok && DebugAllocatorLiveBytes(&dbg) == (32 + 48);

In AllocDebug.c:213:

        }
        ok = ok && (DebugAllocatorFreedCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In AllocDebug.c:235:

        u8 *grown = (u8 *)AllocatorRealloc(adbg, p, 200);
        ok        = ok && (grown != NULL) && (grown[0] == 'h') && (grown[15] == '!');
        ok        = ok && (DebugAllocatorLiveCount(&dbg) == 1);
        ok        = ok && (DebugAllocatorLiveBytes(&dbg) == 200);

In AllocDebug.c:249:

    
        void *p   = AllocatorAlloc(adbg, 24, false);
        bool  ok  = (p != NULL) && (DebugAllocatorLiveCount(&dbg) == 1);
        void *nil = AllocatorRealloc(adbg, p, 0);
        ok        = ok && (nil == NULL) && (DebugAllocatorLiveCount(&dbg) == 0);

In AllocDebug.c:251:

        bool  ok  = (p != NULL) && (DebugAllocatorLiveCount(&dbg) == 1);
        void *nil = AllocatorRealloc(adbg, p, 0);
        ok        = ok && (nil == NULL) && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In AllocDebug.c:262:

    
        void *p  = AllocatorRealloc(adbg, NULL, 32);
        bool  ok = (p != NULL) && (DebugAllocatorLiveCount(&dbg) == 1);
        if (p)
            AllocatorFree(adbg, p);

In AllocDebug.c:280:

    
        void *p  = AllocatorAlloc(adbg, 64, true);
        bool  ok = (p != NULL) && (DebugAllocatorLiveCount(&dbg) == 1);
        ok       = ok && (DebugAllocatorLiveBytes(&dbg) == 64);
        ok       = ok && (((u64)p & 0xfff) == 0); // page-aligned

In AllocDebug.c:285:

    
        AllocatorFree(adbg, p);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In AllocDebug.c:557:

    
        ok = ok && (DebugAllocatorOverflows(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In AllocDebug.c:762:

        ok       = ok && (AllocatorFailedAllocations(adbg) == 1);
        // No live record / bytes for a failed alloc.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In AllocDebug.c:913:

            ok    = ok && (ps[i] != NULL);
        }
        ok = ok && (DebugAllocatorLiveCount(&dbg) == N);
    
        // Every pointer must resolve to its own live record (hash + probe

In AllocDebug.c:933:

            ps[i] = NULL;
        }
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In AllocDebug.c:953:

        ok   = ok && (r == 0);
        // The allocation is untouched -- still one live record of 64 bytes.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 1);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 64);

In AllocDebug.c:1046:

        ok         = ok && (grown[50] == 0x5A);
        ok         = ok && (grown[63] == 0x6B);
        ok         = ok && (DebugAllocatorLiveCount(&dbg) == 1);
        ok         = ok && (DebugAllocatorLiveBytes(&dbg) == 200);

In AllocDebug.c:1075:

        for (u32 i = 0; i < 8; i++)
            ok = ok && (shrunk[i] == (u8)(i + 1));
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 1);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 8);

In ArgParse.c:1944:

        // With four registered specs (plus the auto --help spec) left_col is
        // populated; the 414 loop must free each. A removed Deinit leaks them.
        bool ok = (rc == ARG_RUN_HELP) && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In Init.c:13:

    // A test passes iff `ok` held AND the DebugAllocator has no outstanding
    // allocations after the test released everything it owns.
    #define LEAK_CLEAN(dbg) (DebugAllocatorLiveCount(&(dbg)) == 0 && DebugAllocatorLiveBytes(&(dbg)) == 0)
    
    static bool test_graph_reserve_clear(void) {

In Insert.c:265:

        bool result = GraphReserve(&graph, 8);
    
        size before = DebugAllocatorLiveCount(&dbg);
    
        g_fail_copy           = true;

In Insert.c:271:

        g_fail_copy           = false;
    
        size after = DebugAllocatorLiveCount(&dbg);
    
        result = result && (failed_id == 0);

In Insert.c:307:

        result      = result && (GraphCommitChanges(&graph) == 1);
    
        size before = DebugAllocatorLiveCount(&dbg);
    
        g_fail_copy           = true;

In Insert.c:313:

        g_fail_copy           = false;
    
        size after = DebugAllocatorLiveCount(&dbg);
    
        result = result && (failed_id == 0);

In Compare.c:13:

    // Convenience: a test passes iff `ok` held AND the DebugAllocator has no
    // outstanding allocations after the test released everything it owns.
    #define LEAK_CLEAN(dbg) (DebugAllocatorLiveCount(&(dbg)) == 0 && DebugAllocatorLiveBytes(&(dbg)) == 0)
    
    // Leak-only config: live-count tracking, NO per-alloc stack-trace / canary /

In Math.c:13:

    // Convenience: a test passes iff `ok` held AND the DebugAllocator has no
    // outstanding allocations after the test released everything it owns.
    #define LEAK_CLEAN(dbg) (DebugAllocatorLiveCount(&(dbg)) == 0 && DebugAllocatorLiveBytes(&(dbg)) == 0)
    
    // Leak-only config: live-count tracking, NO per-alloc stack-trace / canary /

In Convert.c:13:

    // Convenience: a test passes iff `ok` held AND the DebugAllocator has no
    // outstanding allocations after the test released everything it owns.
    #define LEAK_CLEAN(dbg) (DebugAllocatorLiveCount(&(dbg)) == 0 && DebugAllocatorLiveBytes(&(dbg)) == 0)
    
    // Leak-only config: live-count tracking, NO per-alloc stack-trace / canary /

In BitWise.Simple.c:1153:

        // Real code frees the temp clone inside rotate; with the Deinit
        // removed it survives as a live allocation after bv is torn down.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In BitWise.Simple.c:1195:

        // Real code frees the temp clone inside rotate; with the Deinit
        // removed it survives as a live allocation after bv is torn down.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In Pattern.Simple.c:1638:

        // The rendered bv_str borrows bv's DebugAllocator. Real code frees it;
        // the mutant leaks it, so the live count stays non-zero after teardown.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In Pattern.Simple.c:1681:

        // bv_str (the render of bv) borrows bv's DebugAllocator. Real code
        // frees it; the mutant leaks it.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DefaultAllocatorDeinit(&palloc);

In Math.c:14:

    }
    
    #define LEAK_CLEAN(dbg) (DebugAllocatorLiveCount(&(dbg)) == 0 && DebugAllocatorLiveBytes(&(dbg)) == 0)
    
    #define LEAK_CFG                                                                                                       \

In Math.c:3415:

        // After releasing every Int the test created, nothing the function
        // allocated internally should remain outstanding.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In Math.c:4739:

        IntDeinit(&inverse);
    
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Math.c:4762:

        IntDeinit(&check);
    
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Math.c:4785:

        IntDeinit(&check);
    
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Math.c:4816:

        IntDeinit(&r);
    
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Math.c:4834:

        IntDeinit(&next);
    
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Math.c:4850:

        IntDeinit(&value);
    
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Convert.c:15:

    }
    
    #define LEAK_CLEAN(dbg) (DebugAllocatorLiveCount(&(dbg)) == 0 && DebugAllocatorLiveBytes(&(dbg)) == 0)
    
    #define LEAK_CFG                                                                                                       \

In Convert.c:1634:

        IntDeinit(&parsed);
    
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Write.c:4784:

    #define LEAK_WRITE_EPILOGUE()                                                                                          \
        StrDeinit(&out);                                                                                                   \
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);                           \
        DebugAllocatorDeinit(&dbg);                                                                                        \
        return ok

In Write.c:4795:

    static bool dbg_no_leak(DebugAllocator *dbg, Str *out) {
        StrDeinit(out);
        bool ok = (DebugAllocatorLiveCount(dbg) == 0);
        DebugAllocatorDeinit(dbg);
        return ok;

In Write.c:5475:

        bool           ok  = StrAppendFmt(&out, "{x}", s) && (StrLen(&out) > 0);
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        StrDeinit(&s);

In Write.c:5496:

        ok = ok && StrAppendFmt(&out, "{}", f) && (StrLen(&out) > 0);
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        FloatDeinit(&f);

In Write.c:5524:

    
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Write.c:5550:

    
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Write.c:5576:

    
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Write.c:5603:

    
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Write.c:5630:

    
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Write.c:5654:

    
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Write.c:5680:

        ok = ok && StrAppendFmt(&out, "{}", s) && (StrLen(&out) > 0);
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        StrDeinit(&s);

In Write.c:5693:

        ok = ok && StrAppendFmt(&out, "{}", v) && (StrLen(&out) > 0);
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        IntDeinit(&v);

In Write.c:5706:

        ok = ok && StrAppendFmt(&out, "{}", v) && (StrLen(&out) > 0);
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        FloatDeinit(&v);

In Write.c:5720:

        ok = ok && StrAppendFmt(&out, "{}", v) && (StrLen(&out) > 0);
        StrDeinit(&out);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        BitVecDeinit(&v);

In Read.c:2503:

        if (s)
            AllocatorFree(&dbg.base, s);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2518:

        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 4); // min-width clamp
        BitVecDeinit(&bv);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2543:

        bool ok = (BitVecToInteger(&bv) == 1) && (BitVecLen(&bv) == 3);
        BitVecDeinit(&bv);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2556:

        bool ok = (BitVecLen(&bv) == 5) && (BitVecToInteger(&bv) == 13);
        BitVecDeinit(&bv);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2572:

        StrDeinit(&t);
        IntDeinit(&v);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2639:

        StrDeinit(&t);
        FloatDeinit(&f);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2656:

        StrDeinit(&t);
        FloatDeinit(&f);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2734:

        Zstr           p   = input;
        StrReadFmt(p, fmt, s); // reader frees s on the unterminated/error branch
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2747:

        StrReadFmt(p, "{}", bv);
        BitVecDeinit(&bv);
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2774:

        Zstr           p   = "aaaaaaaaaaaaaaaaaaaaaaaa\\q"; // 24 'a' + invalid \q
        StrReadFmt(p, "{}", s);
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2795:

        StrReadFmt(p, "{}", fv);
        FloatDeinit(&fv);
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Read.c:2829:

    
        IntDeinit(&value);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Read.c:2856:

    
        FloatDeinit(&value);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Init.c:285:

        // Each piece is long enough to force its own heap buffer.
        Str  s      = StrInitFromZstr("alphaaa,betaaaa,gammaaa,deltaaa", &dbg);
        size before = DebugAllocatorLiveCount(&dbg);
    
        Strs parts = StrSplit(&s, ",");

In Init.c:290:

        // Sanity: the split really produced multiple heap-backed elements,
        // otherwise the leak would be unobservable.
        bool produced = VecLen(&parts) == 4 && DebugAllocatorLiveCount(&dbg) > before;
    
        VecDeinit(&parts); // invokes str_deinit per element on real code.

In Init.c:293:

    
        VecDeinit(&parts); // invokes str_deinit per element on real code.
        size after = DebugAllocatorLiveCount(&dbg);
    
        // Real code: every element buffer (+ backing array) freed -> back to

In Init.c:316:

        StrDeinit(&s);
    
        bool result = (DebugAllocatorLiveCount(&dbg) == 0);
        if (!result) {
            WriteFmt("    FAIL: Expected 0 live allocations after StrDeinit\n");

In Remove.c:348:

    
        // Live allocations are non-zero here (clones + table storage).
        bool result = (DebugAllocatorLiveCount(&dbg) > 0);
    
        // Exercise every removal path against the deep-copy map.

In Remove.c:361:

    
        // After deinit, every clone and the table storage must be freed.
        result = result && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In PdbCache.c:400:

        DebugAllocator alloc    = DebugAllocatorInit();
        Allocator     *base     = ALLOCATOR_OF(&alloc);
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        char pe_path[1024];

In PdbCache.c:417:

            PdbCacheDeinit(&cache);
            // Teardown returns every allocation (the failed-lookup candidate too).
            ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
        }

In PdbCache.c:435:

        DebugAllocator alloc    = DebugAllocatorInit();
        Allocator     *base     = ALLOCATOR_OF(&alloc);
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        char pe_path[1024];

In PdbCache.c:455:

            PdbCacheDeinit(&cache);
            // The briefly-opened, then-rejected PDB must be freed.
            ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
        }

In PdbCache.c:495:

    
            // Both modules now open and cached; snapshot the live allocations.
            size mid = DebugAllocatorLiveCount(&alloc);
    
            // Re-resolve B at a different IP: must hit B's existing slot.

In PdbCache.c:500:

            Zstr name2 = NULL;
            bool rb2   = PdbCacheResolve(&cache, (Zstr)b_pe, mbase, mbase + 0x1108, &name2, &off);
            size after = DebugAllocatorLiveCount(&alloc);
    
            ok = ra && rb && rb2 && name2 && ZstrCompare(name2, "winproc") == 0 && after == mid;

In PdbCache.c:524:

        DebugAllocator alloc    = DebugAllocatorInit();
        Allocator     *base     = ALLOCATOR_OF(&alloc);
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        char pe_path[1024];

In PdbCache.c:542:

    
            // A populated cache with an opened PE+PDB sits strictly above baseline.
            bool grew = r && DebugAllocatorLiveCount(&alloc) > baseline;
    
            PdbCacheDeinit(&cache);

In PdbCache.c:546:

            PdbCacheDeinit(&cache);
            // Correct teardown releases every cached allocation.
            ok = grew && DebugAllocatorLiveCount(&alloc) == baseline;
        }

In PdbCache.c:710:

        DebugAllocator alloc    = DebugAllocatorInit();
        Allocator     *a        = ALLOCATOR_OF(&alloc);
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        char pe_path[1024];

In PdbCache.c:729:

            ok             = !PdbCacheResolve(&cache, (Zstr)pe_path, 0x140000000ull, 0x140001100ull, &name, NULL);
            PdbCacheDeinit(&cache);
            ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
        }

In PdbCache.c:791:

        DebugAllocator alloc    = DebugAllocatorInit();
        Allocator     *base     = ALLOCATOR_OF(&alloc);
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        char a_pe[1024], a_pdb[1024], b_pe[1024], b_pdb[1024];

In PdbCache.c:813:

    
            // A populated two-entry cache sits strictly above baseline.
            bool grew = ra && rb && DebugAllocatorLiveCount(&alloc) > baseline;
    
            PdbCacheDeinit(&cache);

In PdbCache.c:817:

            PdbCacheDeinit(&cache);
            // Freeing EVERY entry (not just the first) returns to baseline.
            ok = grew && DebugAllocatorLiveCount(&alloc) == baseline;
        }

In SysDns.c:1318:

        u64 plen = StrLen(&path);
    
        size baseline = DebugAllocatorLiveCount(&alloc);
    
        DnsResolver r;

In SysDns.c:1325:

        DnsResolverDeinit(&r);
    
        bool ok = DebugAllocatorLiveCount(&alloc) == baseline;
    
        drop_temp(&path);

In SysDns.c:2059:

        DebugAllocator alloc    = DebugAllocatorInit();
        Allocator     *a        = ALLOCATOR_OF(&alloc);
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        DnsResolver r;

In SysDns.c:2064:

        resolver_init_crafted(&r, a);
    
        bool grew = DebugAllocatorLiveCount(&alloc) > baseline;
    
        DnsResolverDeinit(&r);

In SysDns.c:2068:

        DnsResolverDeinit(&r);
    
        bool back = DebugAllocatorLiveCount(&alloc) == baseline;
        bool ok   = grew && back && r.allocator == NULL;

In SysDns.c:2078:

        DebugAllocator alloc    = DebugAllocatorInit();
        Allocator     *a        = ALLOCATOR_OF(&alloc);
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        DnsResolver r;

In SysDns.c:2085:

        DnsResolverDeinit(&r);
    
        bool back = DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In MachoCache.c:619:

        bool      ok       = mc_write_file(bin_path, mc_bin_buf, bin_size);
    
        size baseline = DebugAllocatorLiveCount(&dbg);
    
        MachoCache cache      = MachoCacheInit(base);

In MachoCache.c:630:

    
        // Cache now holds allocations; live count must have grown.
        ok = ok && DebugAllocatorLiveCount(&dbg) > baseline;
    
        MachoCacheDeinit(&cache);

In MachoCache.c:633:

    
        MachoCacheDeinit(&cache);
        ok = ok && DebugAllocatorLiveCount(&dbg) == baseline;
    
        FileRemove(bin_path);

In MachoCache.c:656:

        ok              = ok && mc_write_file(bin_b, mc_dsym_buf, sz_b);
    
        size baseline = DebugAllocatorLiveCount(&dbg);
    
        MachoCache cache = MachoCacheInit(base);

In MachoCache.c:668:

        ok             = ok && MachoCacheResolve(&cache, bin_b, 0, 0x100000110ull, &name, &off);
        ok             = ok && VecLen(&cache.entries) == 2;
        size after_two = DebugAllocatorLiveCount(&dbg);
    
        // Re-resolve module B: its entry lives at index 1, so the find loop

In MachoCache.c:678:

        ok = ok && MachoCacheResolve(&cache, bin_b, 0, 0x100000110ull, &name, &off);
        ok = ok && VecLen(&cache.entries) == 2;
        ok = ok && DebugAllocatorLiveCount(&dbg) == after_two;
    
        // Re-resolve module A (index 0) too: still a hit, no growth.

In MachoCache.c:683:

        ok = ok && MachoCacheResolve(&cache, bin_a, 0, 0x100000110ull, &name, &off);
        ok = ok && VecLen(&cache.entries) == 2;
        ok = ok && DebugAllocatorLiveCount(&dbg) == after_two;
    
        // Two entries are live; MachoCacheDeinit must free BOTH and return to

In MachoCache.c:689:

        // entry 0 and leaks entry 1.
        MachoCacheDeinit(&cache);
        ok = ok && DebugAllocatorLiveCount(&dbg) == baseline;
    
        FileRemove(bin_a);

In MachoCache.c:715:

        ok                  = ok && mc_write_file(dsym_path, mc_dsym_buf, dsym_size);
    
        size baseline = DebugAllocatorLiveCount(&dbg);
    
        MachoCache cache    = MachoCacheInit(base);

In MachoCache.c:722:

        bool       resolved = MachoCacheResolve(&cache, bin_path, 0, 0x100000208ull, &name, &offset);
        ok                  = ok && resolved && name && ZstrCompare(name, "dsym_only_fn") == 0 && offset == 0x8;
        ok                  = ok && DebugAllocatorLiveCount(&dbg) > baseline;
    
        MachoCacheDeinit(&cache);

In MachoCache.c:725:

    
        MachoCacheDeinit(&cache);
        ok = ok && DebugAllocatorLiveCount(&dbg) == baseline;
    
        FileRemove(bin_path);

In MachoCache.c:756:

        ok                  = ok && mc_write_file(dsym_path, mc_dsym_buf, dsym_size);
    
        size baseline = DebugAllocatorLiveCount(&dbg);
    
        MachoCache cache = MachoCacheInit(base);

In MachoCache.c:764:

    
        MachoCacheDeinit(&cache);
        ok = ok && DebugAllocatorLiveCount(&dbg) == baseline;
    
        FileRemove(bin_path);

In MachoCache.c:798:

        ok                  = ok && mc_write_file(dsym_path, mc_dsym_buf, dsym_size);
    
        size baseline = DebugAllocatorLiveCount(&dbg);
    
        MachoCache cache  = MachoCacheInit(base);

In MachoCache.c:806:

        bool resolved = MachoCacheResolve(&cache, bin_path, 0, low + 0x20, &name, &offset);
        ok            = ok && resolved && name && ZstrCompare(name, fn_name) == 0 && offset == 0x20;
        ok            = ok && DebugAllocatorLiveCount(&dbg) > baseline;
    
        MachoCacheDeinit(&cache);

In MachoCache.c:809:

    
        MachoCacheDeinit(&cache);
        ok = ok && DebugAllocatorLiveCount(&dbg) == baseline;
    
        FileRemove(bin_path);

In MachoCache.c:1268:

        ok                  = ok && bl_write_file(dsym_path, bl_dsym_buf, dsym_size);
    
        size baseline = DebugAllocatorLiveCount(&dbg);
    
        MachoCache cache    = MachoCacheInit(base);

In MachoCache.c:1275:

        bool       resolved = MachoCacheResolve(&cache, bin_path, 0, low + 0x14, &name, &offset);
        ok                  = ok && resolved && name && ZstrCompare(name, fn_name) == 0 && offset == 0x14;
        ok                  = ok && DebugAllocatorLiveCount(&dbg) > baseline;
    
        MachoCacheDeinit(&cache);

In MachoCache.c:1278:

    
        MachoCacheDeinit(&cache);
        ok = ok && DebugAllocatorLiveCount(&dbg) == baseline;
    
        FileRemove(bin_path);

In SymbolResolver.c:422:

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

In SymbolResolver.c:426:

        ResolvedSymbol rb;
        ok         = ok && SymbolResolverResolve(&res, (void *)&sr1_marker_b, &rb) && rb.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);
    
        ok = ok && live2 == live1;                                   // no re-open

In SymbolResolver.c:450:

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

In SymbolResolver.c:454:

        ResolvedSymbol rd;
        ok         = ok && SymbolResolverResolve(&res, (void *)&sr_cache_data_marker, &rd) && rd.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);
    
        ok = ok && live2 == live1;                                   // fallback hit, no re-open

In SymbolResolver.c:480:

        u64 other  = 0;
        ok         = ok && find_other_module_addr(ra.module_path, &other);
        size live1 = DebugAllocatorLiveCount(&alloc);
    
        ResolvedSymbol ro;

In SymbolResolver.c:484:

        ResolvedSymbol ro;
        ok         = ok && SymbolResolverResolve(&res, (void *)other, &ro) && ro.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);
    
        ok = ok && ZstrCompare(ro.module_path, ra.module_path) != 0; // distinct module

In SymbolResolver.c:512:

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

In SymbolResolver.c:516:

        ResolvedSymbol r2;
        ok         = ok && SymbolResolverResolve(&res, (void *)other, &r2) && r2.module_path;
        size live2 = DebugAllocatorLiveCount(&alloc);
    
        ok = ok && live2 == live1;                                   // hit on entry[1], no re-open

In SymbolResolver.c:530:

    bool test_sr_deinit_frees_everything(void) {
        DebugAllocator alloc    = DebugAllocatorInit();
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        SymbolResolver res;

In SymbolResolver.c:541:

    
        SymbolResolverDeinit(&res);
        ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In SymbolResolver.c:626:

    bool test_sr_deinit_two_modules_frees_all(void) {
        DebugAllocator alloc    = DebugAllocatorInit();
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        SymbolResolver res;

In SymbolResolver.c:645:

    
        SymbolResolverDeinit(&res);
        ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In SymbolResolver.c:686:

    bool test_sr_findfde_teardown_frees_cfi(void) {
        DebugAllocator alloc    = DebugAllocatorInit();
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        SymbolResolver res;

In SymbolResolver.c:698:

        u64             base = 0;
        bool            ok   = SymbolResolverFindFde(&res, (void *)&sr1_marker_a, &cfi, &fde, &base);
        ok                   = ok && DebugAllocatorLiveCount(&alloc) > baseline; // CFI was built
    
        SymbolResolverDeinit(&res);

In SymbolResolver.c:701:

    
        SymbolResolverDeinit(&res);
        ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In SidecarDwarf.c:56:

    bool test_sidecardwarf_teardown_frees_sidecar_functions(void) {
        DebugAllocator alloc    = DebugAllocatorInit();
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        SymbolResolver res;

In SidecarDwarf.c:67:

        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;
    
        SymbolResolverDeinit(&res);

In SidecarDwarf.c:70:

    
        SymbolResolverDeinit(&res);
        ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In SidecarSub.c:59:

    bool test_sidecarsub_teardown_frees(void) {
        DebugAllocator alloc    = DebugAllocatorInit();
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        SymbolResolver res;

In SidecarSub.c:70:

        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;
    
        SymbolResolverDeinit(&res);

In SidecarSub.c:73:

    
        SymbolResolverDeinit(&res);
        ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In Sidecar.c:72:

    bool test_sidecar_teardown_frees_sidecar(void) {
        DebugAllocator alloc    = DebugAllocatorInit();
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        SymbolResolver res;

In Sidecar.c:85:

        // entry actually carries one.
        ok = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "sidecar_marker") != NULL;
        ok = ok && DebugAllocatorLiveCount(&alloc) > baseline;
    
        SymbolResolverDeinit(&res);

In Sidecar.c:88:

    
        SymbolResolverDeinit(&res);
        ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In DwarfFallback.c:136:

    bool test_dwarffallback_teardown_frees(void) {
        DebugAllocator alloc    = DebugAllocatorInit();
        size           baseline = DebugAllocatorLiveCount(&alloc);
    
        SymbolResolver res;

In DwarfFallback.c:149:

        // line table alongside it).
        ok = ok && r.symbol_name && ZstrFindSubstring(r.symbol_name, "df_marker_a") != NULL;
        ok = ok && DebugAllocatorLiveCount(&alloc) > baseline;
    
        SymbolResolverDeinit(&res);

In DwarfFallback.c:152:

    
        SymbolResolverDeinit(&res);
        ok = ok && DebugAllocatorLiveCount(&alloc) == baseline;
    
        DebugAllocatorDeinit(&alloc);

In Dns.c:1878:

        DnsResponseDeinit(&resp);
    
        bool match = (ok == false) && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return match;

In Dns.c:1901:

        DnsResponseDeinit(&resp);
    
        bool match = (ok == false) && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return match;

In Dns.c:2090:

    
        DnsResponseDeinit(&resp);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Dns.c:2158:

    
        DnsResponseDeinit(&resp);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Dns.c:2186:

    
        DnsResponseDeinit(&resp);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Pdb.c:2412:

        // Crux: the fail path must have freed every allocation, including the
        // taken data buffer and the per-stream arrays.
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
    
        DebugAllocatorDeinit(&dbg);

In Pdb.c:2441:

    
        // Everything PdbDeinit owns -- including the name pool -- must be gone.
        ok = ok && DebugAllocatorLiveCount(&dbg) == 0;
    
        DebugAllocatorDeinit(&dbg);

In ProcMaps.c:363:

        Allocator     *base = ALLOCATOR_OF(&dbg);
    
        size before = DebugAllocatorLiveCount(&dbg);
    
        ProcMaps maps;

In ProcMaps.c:373:

        // The load must have taken at least one live allocation (raw buffer
        // and/or entries vector); otherwise the assertion below is vacuous.
        size during = DebugAllocatorLiveCount(&dbg);
        bool ok     = during > before;

In ProcMaps.c:379:

    
        // After Deinit every load allocation is gone again.
        size after = DebugAllocatorLiveCount(&dbg);
        ok         = ok && after == before;

In ProcMaps.c:645:

        }
    
        size before = DebugAllocatorLiveCount(&dbg);
    
        ProcMaps m;

In ProcMaps.c:656:

    
        // That arm must have freed everything the partial read reserved.
        size after = DebugAllocatorLiveCount(&dbg);
        ok         = ok && (after == before);

In Http.c:308:

        // reclaim the source so only the vec's deep copies remain live.
        HttpHeaderDeinit(&hh);
        ok = ok && (DebugAllocatorLiveCount(&dbg) > 0);
    
        // VecDeinit runs http_header_deinit on the surviving copy.

In Http.c:312:

        // VecDeinit runs http_header_deinit on the surviving copy.
        VecDeinit(&headers);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In Http.c:333:

        Zstr        next = HttpRequestParse(&req, raw);
        bool        ok   = (next != raw) && (StrLen(&req.url) > 0);
        ok               = ok && (DebugAllocatorLiveCount(&dbg) > 0);
    
        HttpRequestDeinit(&req);

In Http.c:336:

    
        HttpRequestDeinit(&req);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In Http.c:364:

        StrDeinit(&second);
        HttpResponseDeinit(&response);
        bool ok = (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In Http.c:402:

        StrDeinit(&path);
        HttpResponseDeinit(&response);
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
    
        DebugAllocatorDeinit(&dbg);

In MachO.c:1505:

    
        // The open must have failed AND left no live allocations behind.
        bool ok = !opened && DebugAllocatorLiveCount(&dbg) == 0;
    
        DebugAllocatorDeinit(&dbg);

In Dwarf.c:2642:

        }
    
        size       before = DebugAllocatorLiveCount(&dbg);
        DwarfLines lines;
        bool       built = DwarfLinesBuildFromElf(&lines, &elf, base);

In Dwarf.c:2657:

        // pool freed by DwarfLinesDeinit -> back to baseline. Mutant (no
        // cu_strings_deinit): the per-CU scratch vectors leak -> after > before.
        size after = DebugAllocatorLiveCount(&dbg);
        ok         = ok && (after == before);

In Dwarf.c:2688:

        }
    
        size       before = DebugAllocatorLiveCount(&dbg);
        DwarfLines lines;
        bool       built = DwarfLinesBuildFromElf(&lines, &elf, base);

In Dwarf.c:2698:

            ok                      = ok && e && e->file && ZstrCompare(e->file, "source.c") == 0;
            // After the build there must be live allocations to release.
            ok = ok && (DebugAllocatorLiveCount(&dbg) > before);
            DwarfLinesDeinit(&lines);
        }

In Dwarf.c:2704:

        // Real Deinit frees entries + string_pool -> baseline. Mutant leaves
        // the string pool buffer live -> after > before.
        size after = DebugAllocatorLiveCount(&dbg);
        ok         = ok && (after == before);

In Dwarf.c:3412:

        ElfDeinit(&elf);
    
        bool ok = !built && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Dwarf.c:3462:

        ElfDeinit(&elf);
    
        bool ok = !built && (DebugAllocatorLiveCount(&dbg) == 0);
        DebugAllocatorDeinit(&dbg);
        return ok;

In Parse.c:651:

        MapDeinit(&cfg);
    
        ok = DebugAllocatorLiveCount(&dbg) == 0;
        DebugAllocatorDeinit(&dbg);
        return ok;

In Parse.c:717:

    
        // The stripped-away old value buffer must already be freed.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Parse.c:748:

    
        // The parser's local key copy must already be freed.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Parse.c:778:

    
        // The parser's local value copy must already be freed.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

In Parse.c:819:

    
        // Every transient lookup key must already be freed.
        ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
        ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);

Last updated on July 1, 2026

DebugAllocatorLiveBytes DebugAllocatorOverflows