Editing Valgrind (section)

===Memcheck===
There are multiple tools included with Valgrind (and several external ones). The default (and most used) tool is ''Memcheck''. Memcheck inserts extra [[instrumentation (computer programming)|instrumentation]] code around almost all instructions, which keeps track of the ''validity'' (all unallocated memory starts as invalid or "undefined", until it is initialized into a deterministic state, possibly from other memory) and ''addressability'' (whether the memory address in question points to an allocated, non-freed memory block), stored in the so-called ''V bits'' and ''A bits'' respectively. As data is moved around or manipulated, the instrumentation code keeps track of the A and V bits, so they are always correct on a single-bit level.

In addition, Memcheck replaces the standard [https://en.cppreference.com/w/cpp/memory/new/operator_new C++ allocators] and [[C dynamic memory allocation|C memory allocator]] with its own implementation, which also includes ''memory guards'' around all allocated blocks (with the A bits set to "invalid"). This feature enables Memcheck to detect [[off-by-one error]]s where a program reads or writes outside an allocated block by a small amount. The problems Memcheck can detect and warn about include the following:
* Reading uninitialized memory
* Reading/writing invalid memory which may be
** memory that has been <code>free</code>'d
** memory outside of <code>malloc</code>'d blocks
** memory below the stack pointer
* Use of incorrect parameters for system calls
* Unsafe overlapping memory copies with <code>mem*</code> and <code>str*</code> functions
* [[Memory leak]]s
* Mismatched allocations and deallocations which may be
** mixing C and C++ e.g., <code>malloc</code> and <code>delete</code>
** mixing scalar and array e.g., <code>new</code> and <code>delete[]</code>
** sized deallocation not the same size as allocation
** aligned deallocation not the same alignment as allocation
* Use of incorrect alignment
* Use of <code>realloc</code> with a size of zero

The price of this is lost performance. Programs running under Memcheck usually run 20–30 times slower<ref>{{Cite web|url=https://valgrind.org/docs/manual/quick-start.html#quick-start.mcrun|title = Valgrind}}</ref> than running outside Valgrind and use more memory (there is a memory penalty per allocation). Thus, few developers run their code under Memcheck (or any other Valgrind tool) all the time. They most commonly use such tools either to trace down some specific bug, or to verify that there are no latent bugs (of the kind Memcheck can detect) in the code.