PdbOpenFromMemoryCopy

Documentation

API Reference

Description

Open and parse a PDB from an in-memory byte range – R-value / copy form (mirrors VecInsertR).

Parser allocates its own buffer through alloc and MemCopys the caller’s bytes in. Caller’s pointer is never retained.

Success

Returns true; out owns an independent copy of data.

Failure

Returns false; out zeroed; caller’s data untouched.

Usage example (Cross-references)

Usage examples (Cross-references)

In Pdb.c:732:

    bool pdb_open_from_memory_copy(Pdb *out, const u8 *data, size data_size, Allocator *alloc) {
        if (!out || !data || !alloc) {
            LOG_FATAL("PdbOpenFromMemoryCopy: NULL argument (contract violation)");
        }
        Buf copy = BufInit(alloc);

In Pdb.c:736:

        Buf copy = BufInit(alloc);
        if (!BufReserve(&copy, (u64)data_size)) {
            LOG_ERROR("PdbOpenFromMemoryCopy: allocation failed ({} bytes)", (u64)data_size);
            return false;
        }

In Pdb.c:102:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, blob, sizeof(blob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:128:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, garbage, sizeof(garbage), base);
    
        DefaultAllocatorDeinit(&alloc);

In Pdb.c:290:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, fblob, sizeof(fblob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:436:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, mblob, sizeof(mblob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:501:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, buf, sizeof(buf), base);
    
        DefaultAllocatorDeinit(&alloc);

In Pdb.c:517:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, buf, sizeof(buf), base);
    
        DefaultAllocatorDeinit(&alloc);

In Pdb.c:678:

    static int open_and_count(Allocator *base, u32 *out_rva0) {
        Pdb pdb;
        if (!PdbOpenFromMemoryCopy(&pdb, gblob, sizeof(gblob), base))
            return -1;
        int n = (int)VecLen(&pdb.functions);

In Pdb.c:979:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = ok && pdb.block_size == B_BS;

In Pdb.c:999:

        u32              blob_len = build_blob_m2(bs, sizes, 2, NULL, NULL);
        Pdb              pdb;
        bool             ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = (pdb.block_size == bs) && (pdb.num_streams == 2);

In Pdb.c:1038:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, buf, sizeof(buf), base);
        DefaultAllocatorDeinit(&alloc);
        return ok;

In Pdb.c:1057:

            g_blob[b]    ^= 0xFF; // corrupt one magic byte
            Pdb  pdb;
            bool opened = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
            if (opened) {
                PdbDeinit(&pdb);

In Pdb.c:1081:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, buf, sizeof(buf), base);
        DefaultAllocatorDeinit(&alloc);
        return ok;

In Pdb.c:1102:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        DefaultAllocatorDeinit(&alloc);
        return ok;

In Pdb.c:1120:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            // Last content page (stream 1) is the final page in the blob.

In Pdb.c:1141:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = pdb.dir_stream_blocks_count == 1;

In Pdb.c:1225:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_tblob, sizeof(g_tblob), base);
        if (ok) {
            ok = ok && pdb.num_streams == T_NUM_STREAMS;

In Pdb.c:1254:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = ok && pdb.num_streams == 5;

In Pdb.c:1291:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = ok && pdb.stream_block_counts[1] == 2;

In Pdb.c:1318:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = ok && pdb.num_streams == 1;

In Pdb.c:1344:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        DefaultAllocatorDeinit(&alloc);
        return ok;

In Pdb.c:1364:

    
        Pdb  pdb;
        bool ok = !PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        DefaultAllocatorDeinit(&alloc);
        return ok;

In Pdb.c:1398:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, Z_PAGES * Z_BS, base);
        if (ok) {
            ok = pdb.num_streams == 0;

In Pdb.c:1423:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = ok && pdb.num_streams == 3;

In Pdb.c:1452:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob, blob_len, base);
        if (ok) {
            ok = ok && pdb.num_streams == 2;

In Pdb.c:1504:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_hblob, sizeof(g_hblob), base);
        if (ok) {
            ok = ok && pdb.dir_stream_blocks_count == H_DIR_BLOCKS;

In Pdb.c:1675:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_filter, sizeof(g_blob_filter), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:1736:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_sect, sizeof(g_blob_sect), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:1793:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_oob, sizeof(g_blob_oob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:1849:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_size, sizeof(g_blob_size), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:1916:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_sort, sizeof(g_blob_sort), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:1977:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_mal, sizeof(g_blob_mal), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:2035:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_ovf, sizeof(g_blob_ovf), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:2229:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, xblob, sizeof(xblob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:2271:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, xblob, sizeof(xblob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:2345:

    
        Pdb  pdb;
        bool open_ok = PdbOpenFromMemoryCopy(&pdb, sblob, sizeof(sblob), base);
        // Real code: rejected.
        bool ok = !open_ok;

In Pdb.c:2365:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, sblob, sizeof(sblob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:2430:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, xblob, sizeof(xblob), base);
        if (!ok) {
            DebugAllocatorDeinit(&dbg);

In Pdb.c:2513:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, xblob, sizeof(xblob), base);
        if (!ok) {
            DefaultAllocatorDeinit(&alloc);

In Pdb.c:2687:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
        if (ok) {
            ok = VecLen(&pdb.functions) == 1;

In Pdb.c:2722:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
        if (ok) {
            ok = VecLen(&pdb.functions) == 0;

In Pdb.c:2752:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
        if (ok) {
            ok = VecLen(&pdb.functions) == 1;

In Pdb.c:2784:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
        if (ok) {
            ok = VecLen(&pdb.functions) == 3;

In Pdb.c:2815:

    
        Pdb  pdb;
        bool ok = PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
        if (ok) {
            ok = VecLen(&pdb.functions) == 1;

In Pdb.c:2850:

    
        Pdb  pdb;
        bool rejected = !PdbOpenFromMemoryCopy(&pdb, g_blob_m5, P5_BLOB_SIZE, base);
        if (!rejected)
            PdbDeinit(&pdb);

In Pdb.c:3002:

    static int open_count(Allocator *base, Blob *b) {
        Pdb pdb;
        if (!PdbOpenFromMemoryCopy(&pdb, b->bytes, b->len, base))
            return -1;
        int n = (int)VecLen(&pdb.functions);

In Pdb.c:3033:

    
        Pdb pdb;
        if (!PdbOpenFromMemoryCopy(&pdb, b.bytes, b.len, base)) {
            DefaultAllocatorDeinit(&alloc);
            return false;

In Pdb.c:3076:

    
        Pdb  pdb;
        bool opened = PdbOpenFromMemoryCopy(&pdb, b.bytes, b.len, base);
        bool ok     = opened && VecLen(&pdb.functions) == 1 && pdb.num_streams == N;
        if (ok) {

In Pdb.c:3117:

    
        Pdb  pdb;
        bool opened = PdbOpenFromMemoryCopy(&pdb, b.bytes, b.len, base);
        bool ok     = opened && VecLen(&pdb.functions) == 1;
        if (ok) {

Last updated on July 1, 2026

PdbOpenFromMemory PdbResolveRva