Lines Matching full:blocks
62 // blocks (they are excluded so that later on we can differentiate
63 // between heap blocks that are indirectly leaked vs. directly leaked).
64 // - heap-allocated blocks. A block is a mempool chunk or a malloc chunk
65 // that doesn't contain a mempool chunk. Nb: the terms "blocks" and
74 // Root set nodes only point to blocks. Blocks only point to blocks;
96 // directly lost blocks, and the indirectly lost ones will be fixed as
97 // part of that. Any possibly lost blocks will just be due to random
121 // of indirectly leaked blocks(!) It would be better named --show-all or
122 // --show-all-heap-blocks, because that's the end result.
148 // ==20397== 16 bytes in 1 blocks are indirectly lost in loss record 9 of 15
153 // ==20397== 32 (16 direct, 16 indirect) bytes in 1 blocks are definitely
168 // ==20397== 16 bytes in 1 blocks are definitely lost in loss record 14
176 // then the resultant indirectly lost blocks and make it clear the
183 // - Find all the blocks (a.k.a. chunks) to check. Mempool chunks require
184 // some special treatment because they can be within malloc'd blocks.
192 // this can push more blocks onto the mark stack. We repeat until the
199 // - We process the mark stack again, this time grouping blocks into cliques
201 // - We group blocks by their ExeContexts and categorisation, and print them
208 // - Each directly lost block has zero or more indirectly lost blocks
209 // hanging off it. All these blocks together form a "clique". The
300 // Special-case zero-sized blocks - treat them as if they had
440 // to support printing the list of blocks belonging to a loss record.
592 // sure any blocks it points to are correctly marked.
601 // sure any blocks it points to are correctly marked.
631 // Note that, unlike reachable blocks, we currently don't distinguish
686 // clique is the "highest level clique" in which indirectly leaked blocks have
699 // record to describe the hierarchy of indirectly leaked blocks.
916 // includes indirectly lost blocks!
1123 VG_(umsg)(" definitely lost: %'lu%s bytes in %'lu%s blocks\n",
1128 VG_(umsg)(" indirectly lost: %'lu%s bytes in %'lu%s blocks\n",
1133 VG_(umsg)(" possibly lost: %'lu%s bytes in %'lu%s blocks\n",
1138 VG_(umsg)(" still reachable: %'lu%s bytes in %'lu%s blocks\n",
1143 VG_(umsg)(" suppressed: %'lu%s bytes in %'lu%s blocks\n",
1160 VG_(umsg)("Reachable blocks (those to which a pointer "
1172 // print recursively all indirectly leaked blocks collected in clique.
1268 // If searched = 0, scan memory root set, pushing onto the mark stack the blocks
1365 VG_(umsg)("All heap blocks were freed -- no leaks are possible\n");
1371 // Sort the array so blocks are in ascending order in memory.
1385 // for mempool chunks, but if custom-allocated blocks are put in a separate
1386 // table from normal heap blocks it makes free-mismatch checking more
1432 VG_(umsg)("Blocks allocation contexts:\n"),
1463 VG_(umsg)( "Searching for pointers to %'d not-freed blocks\n",
1467 // Scan the memory root-set, pushing onto the mark stack any blocks
1474 // Process the pushed blocks. After this, every block that is reachable
1483 // Trace all the leaked blocks to determine which are directly leaked and
1485 // the mark stack, and find all the as-yet-Unreached blocks reachable
1488 // found blocks was itself a clique leader (from a previous clique), then
