Valgrind () is a programming tool
for memory debugging
, memory leak
detection, and profiling
Valgrind was originally designed to be a free memory debugging
tool for Linux
, but has since evolved to become a generic framework for creating dynamic analysis tools such as checkers and profilers.
The name Valgrind is a reference to the main entrance of Valhalla
from Norse Mythology. During development (before release) the project was named Heimdall
; however, the name would have conflicted with a security package.
Valgrind is in essence a virtual machine
(JIT) compilation techniques, including dynamic recompilation
. Nothing from the original program ever gets run directly on the host processor
. Instead, Valgrind first translates the program into a temporary, simpler form called Intermediate Representation (IR), which is a processor-neutral, SSA
-based form. After the conversion, a ''tool'' (see below) is free to do whatever transformations it would like on the IR, before Valgrind translates the IR back into machine code and lets the host processor run it. Valgrind recompiles binary code
to run on host and target (or simulated) CPUs of the same architecture. It also includes a GDB
stub to allow debugging of the target program as it runs in Valgrind, with "monitor commands" that allow querying the Valgrind tool for various information.
A considerable amount of performance is lost in these transformations (and usually, the code the tool inserts); usually, code run with Valgrind and the "none" tool (which does nothing to the IR) runs at 20% to 25% of the speed of the normal program.
There are multiple tools included with Valgrind (and several external ones). The default (and most used) tool is ''Memcheck''. Memcheck inserts extra 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 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:
* Use of uninitialized memory
* Reading/writing memory after it has been
* Reading/writing off the end of
* Memory leak
The price of this is lost performance. Programs running under Memcheck usually run 20–30 times slower 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.
In addition to Memcheck, Valgrind has several other tools:
*''None'', runs the code in the virtual machine without performing any analysis and thus has the smallest possible CPU and memory overhead of all tools. Since valgrind itself provides a trace back from a segmentation fault
, the ''none'' tool provides this traceback at minimal overhead.
*''Addrcheck'', similar to Memcheck but with much smaller CPU and memory overhead, thus catching fewer types of bugs. Addrcheck has been removed as of version 3.2.0.
*''Massif'', a heap profiler
. The separate GUI
massif-visualizer visualizes output from Massif.
*''Helgrind'' and ''DRD'', detect race condition
s in multithreaded code
*''Cachegrind'', a cache
profiler. The separate GUI KCacheGrind visualizes output from Cachegrind.
*''Callgrind'', a callgraph
analyzer created by Josef Weidendorfer was added to Valgrind as of version 3.2.0. KCacheGrind can visualize output from Callgrind.
*''DHAT'', dynamic heap analysis tool which analyzes how much memory is allocated and for how long as well as patterns of memory usage.
*''exp-sgcheck'' (named ''exp-ptrcheck'' prior to version 3.7), an experimental tool to find stack and global array overrun errors which Memcheck cannot find. Some code results in false positives from this tool.
*''exp-bbv'', a performance simulator that extrapolates performance from a small sample set.
There are also several externally developed tools available. One such tool is ThreadSanitizer, another detector of race condition
As of version 3.4.0, Valgrind supports Linux
. Support for was added in version 3.5.0. Support for Linux on ARMv7
(used for example in certain smartphones
) was added in version 3.6.0. Support for Solaris
was added in version 3.11.0.
There are unofficial ports to other UNIX-like platforms (like FreeBSD
, and NetBSD
). From version 3.7.0 the ARM
platform support was added.
Since version 3.9.0 there is support for Linux on MIPS64
little and big endian, for MIPS DSP ASE on MIPS32, for s390x
Decimal Floating Point instructions, for POWER8
(Power ISA 2.07
) instructions, for Intel AVX2
instructions, for Intel Transactional Synchronization Extensions, both RTM and HLE and initial support for Hardware Transactional Memory on POWER.
History and development
It is named after the main entrance to Valhalla
in Norse mythology
The original author of Valgrind is Julian Seward
, who in 2006 won a Google-O'Reilly Open Source Award
for his work on Valgrind.
Several others have also made significant contributions, including Cerion Armour-Brown, Jeremy Fitzhardinge, Tom Hughes, Nicholas Nethercote, Paul Mackerras, Dirk Mueller, Bart Van Assche, Josef Weidendorfer, and Robert Walsh.
It is used by a number of Linux-based projects.
Limitations of Memcheck
In addition to the performance penalty, an important limitation of Memcheck is its inability to detect all cases of bounds errors in the use of static or stack-allocated data.Valgrind FAQ
/ref> The following code will pass the ''Memcheck'' tool in Valgrind without incident, despite containing the errors described in the comments:
The experimental valgrind tool exp-sgcheck has been written to address this limitation in Memcheck. It will detect array overrun errors, provided the first access to an array is within the array bounds. Note that exp-sgcheck will not detect the array overrun in the code above, since the first access to an array is out of bounds, but it will detect the array overrun error in the following code.
The inability to detect all errors involving the access of stack allocated data is especially noteworthy since
certain types of stack errors make software vulnerable to the classic
stack smashing exploit.
* Dynamic program analysis
* AddressSanitizer et al.
Category:Free memory debuggers
Category:Free memory management software
Category:Free software testing tools
Category:Software testing tools