The latest version of this document is always available at http://gcc.gnu.org/onlinedocs/libstdc++/debug.html.
To the libstdc++-v3 homepage.
There are numerous things that can be done to improve the ease with which C++ binaries are debugged when using the GNU C++ tool chain. Here are some things to keep in mind when debugging C++ code with GNU tools.
The default optimizations and debug flags for a libstdc++ build are
-g -O2. However, both debug and optimization flags can
be varied to change debugging characteristics. For instance,
turning off all optimization via the -g -O0 flag will
disable inlining, so that stepping through all functions, including
inlined constructors and destructors, is possible. Or, the debug
format that the compiler and debugger use to communicate
information about source constructs can be changed via
-gdwarf-2 or -gstabs flags: some debugging
formats permit more expressive type and scope information to be
shown in gdb.
The default debug information for a particular platform can be
identified via the value set by the PREFERRED_DEBUGGING_TYPE macro
in the gcc sources.
Many other options are available: please see "Options for Debugging Your Program" in Using the GNU Compiler Collection (GCC) for a complete list.
There are two ways to build libstdc++ with debug flags. The first
is to run make from the toplevel in a freshly-configured tree with
specialized debug CXXFLAGS, as in
make CXXFLAGS='-g3 -O0' all
This quick and dirty approach is often sufficient for quick debugging tasks, but the lack of state can be confusing in the long term.
A second approach is to use the configuration flags
--enable-debug
and perhaps
--enable-debug-flags='...'
to create a separate debug build. Both the normal build and the
debug build will persist, without having to specify
CXXFLAGS, and the debug library will be installed in a
separate directory tree, in (prefix)/lib/debug. For
more information, look at the configuration
options document.
There are various third party memory tracing and debug utilities
that can be used to provide detailed memory allocation information
about C++ code. An exhaustive list of tools is not going to be
attempted, but includes mtrace, valgrind,
mudflap, and purify. Also highly
recommended are libcwd and some other one that I
forget right now.
Regardless of the memory debugging tool being used, there is one
thing of great importance to keep in mind when debugging C++ code
that uses new and delete:
there are different kinds of allocation schemes that can be used by
std::allocator . For implementation details, see this
document and look specifically for
GLIBCXX_FORCE_NEW.
In a nutshell, the default allocator used by
std::allocator is a high-performance pool allocator, and can
give the mistaken impression that memory is being leaked, when in
reality the memory is still being used by the library and is reclaimed
after program termination.
For valgrind, there are some specific items to keep in mind. First of all, use a version of valgrind that will work with current GNU C++ tools: the first that can do this is valgrind 1.0.4, but later versions should work at least as well. Second of all, use a completely unoptimized build to avoid confusing valgrind. Third, use GLIBCXX_FORCE_NEW to keep extraneous pool allocation noise from cluttering debug information.
Fourth, it may be necessary to force deallocation in other
libraries as well, namely the "C" library. On linux, this can be
accomplished with the appropriate use of the
__cxa_atexit or atexit functions.
#include <cstdlib>
extern "C" void __libc_freeres(void);
void do_something() { }
int main()
{
atexit(__libc_freeres);
do_something();
return 0;
}
or, using __cxa_atexit:
extern "C" void __libc_freeres(void);
extern "C" int __cxa_atexit(void (*func) (void *), void *arg, void *d);
void do_something() { }
int main()
{
extern void* __dso_handle __attribute__ ((__weak__));
__cxa_atexit((void (*) (void *)) __libc_freeres, NULL,
&__dso_handle ? __dso_handle : NULL);
do_test();
return 0;
}
Suggested valgrind flags, given the suggestions above about setting up the runtime environment, library, and test file, might be:
valgrind -v --num-callers=20 --leak-check=yes --leak-resolution=high --show-reachable=yes a.out
Many options are available for gdb itself: please see "GDB features for C++" in the gdb documentation. Also recommended: the other parts of this manual.
These settings can either be switched on in at the gdb command line, or put into a .gdbint file to establish default debugging characteristics, like so:
set print pretty on set print object on set print static-members on set print vtbl on set print demangle on set demangle-style gnu-v3
The verbose termination handler gives information about uncaught exceptions which are killing the program. It is described in the linked-to page.
Return to the top of the page or to the libstdc++ homepage.
See license.html for copying conditions. Comments and suggestions are welcome, and may be sent to the libstdc++ mailing list.