valgrind

Use the (default) Memcheck tool to show a diagnostic of memory usage by program

$ valgrind [program]

$ valgrind --leak-check=full --show-leak-kinds=all [program]

$ valgrind --tool=cachegrind [program]

$ valgrind --tool=massif --stacks=yes [program]

valgrind [valgrind-options] your-program [program-arguments]

--tool=toolname
    Specifies which Valgrind tool to run. Common tools include memcheck (default), cachegrind, callgrind, helgrind, drd, massif.

--leak-check=yes|no|summary|full
    (Memcheck) Activates memory leak detection. full provides maximum detail, including reachable blocks.

--show-reachable=yes|no
    (Memcheck) When leak-check is full, specifies whether to show reachable (still pointed to) blocks in the leak report.

--track-origins=yes|no
    (Memcheck) Tracks the origin of uninitialized values, helping to pinpoint where they were last defined or allocated.

--log-file=file
    Writes all Valgrind output (errors, statistics) to the specified file instead of stderr.

--num-callers=number
    Specifies the number of stack frames to show in backtraces for errors. Default is 12.

--error-limit=yes|no
    If yes (default), Valgrind stops reporting errors after 1000 unique errors. Set to no to report all errors.

--gen-suppressions=yes|no
    (Memcheck) If yes, Valgrind prints suppression records for each detected error, which can be used to silence specific warnings.

--suppressions=file
    Specifies an extra file from which to read suppression rules. Can be specified multiple times.

--vgdb=yes|no|full
    Enables Valgrind's gdb server. Allows connecting gdb to a running Valgrind process for interactive debugging.

--xml=yes|no
    If yes, Valgrind emits its error and status messages in XML format to the log file (or stderr if no log file).

--trace-children=yes|no
    If yes, Valgrind will trace into child processes created via fork or exec. Default is no.

--verbose
    Be more verbose, showing extra information such as progress messages and detailed error reports.

--quiet
    Be quieter, printing only critical error messages.

--help
    Displays a summary of Valgrind's general options.

--version
    Displays the Valgrind version and copyright information.

Valgrind is an open-source instrumentation framework for building dynamic analysis tools. Its primary and most widely used tool is Memcheck, which is designed to detect a wide range of memory errors in C and C++ programs, such as uninitialized memory reads, invalid memory accesses (reads/writes past allocated blocks, use-after-free), use of freed memory, and memory leaks. Valgrind operates by running your program on a synthetic CPU, which allows it to intercept and analyze all memory accesses and system calls made by the program. This deep level of instrumentation provides highly detailed error reports, including stack traces pointing to the source of the issue.

Beyond Memcheck, Valgrind provides other powerful tools like Cachegrind (cache and branch prediction profiler), Callgrind (call graph and cache profiler), Helgrind and DRD (thread error detectors for race conditions), and Massif (a heap profiler). While extremely effective for debugging and performance analysis, Valgrind significantly slows down program execution (typically 5-10x or more), making it suitable for development and testing environments rather than production. It's an indispensable tool for ensuring software quality and robustness.

Valgrind introduces a significant performance overhead, typically slowing down program execution by 5 to 10 times, and sometimes even more, making it unsuitable for performance-critical production environments. It requires programs to be compiled with debug symbols (-g flag for GCC/Clang) for optimal results, as this allows Valgrind to provide precise file and line number information for errors. While powerful, Valgrind does not detect all types of bugs (e.g., logic errors, deadlocks without specific tools, or certain complex race conditions). Users may need to create suppression files to filter out warnings from third-party libraries or known "safe" issues to focus on critical errors in their own code.

Valgrind output typically shows the type of error (e.g., Invalid read, Leak_DefinitelyLost), the memory address involved, and a stack trace indicating where the error occurred in the source code. The stack trace is crucial for debugging, pointing to the function calls leading up to the error. Understanding the different leak types (definitely lost, indirectly lost, possibly lost, still reachable) is key for effective memory debugging.

To avoid repeated warnings from known issues (e.g., in third-party libraries that you cannot fix, or system libraries), Valgrind allows the creation of "suppression files". These files contain rules that tell Valgrind to ignore specific errors based on their type, function name, or other patterns. This helps developers focus on relevant errors in their own code.

While Memcheck is the most famous, Valgrind offers several other powerful tools. Cachegrind analyzes CPU cache usage and branch prediction, helping optimize performance. Callgrind builds on Cachegrind by creating a call graph of the program, showing function call relationships and costs. Massif profiles heap memory usage over time, visualizing memory consumption patterns. Helgrind and DRD (Data Race Detector) are designed to find threading bugs like race conditions and deadlocks.

Valgrind was initially developed by Julian Seward, with the first public release in 2000. It began primarily as a memory error detector (Memcheck), but its modular architecture allowed it to evolve into a versatile framework. Over the years, many other tools were added, developed by Julian Seward and other contributors, expanding its capabilities to include profiling (Cachegrind, Callgrind, Massif) and concurrency bug detection (Helgrind, DRD). Its open-source nature and effectiveness have made it a widely adopted and indispensable tool in the development and quality assurance processes for C and C++ applications on Linux and other Unix-like systems.

gdb(1), strace(1), ltrace(1), perf(1), ldd(1)