catch event
Stop when event
occurs. event
can be any of the following calls.
-
throw
The throwing of a C++ exception.
-
catch
The catching of a C++ exception.
-
exec
A call to exec.
-
fork
A call to fork
-
vfork
A call to vfork
-
load
-
load libname
The dynamic loading of any
shared library, or the loading of the library, libname.
-
unload
-
unload libname
The unloading of any dynamically
loaded shared library, or the unloading of the library, libname.
tcatch event
Set a catchpoint that is
enabled only for one stop. The catchpoint is automatically deleted after
the first time the event is caught (see previous event
calls for event definitions).
Use the info break
command to list the current catchpoints.
There are currently some
limitations to C++ exception handling (catch throw
and catch catch) in GDB, as
the following discussion describes.
-
If you call a function interactively,
GDB normally returns control to you when the function has finished executing.
If the call raises an exception, however, the call may bypass the mechanism
that returns control to you and cause your program either to abort or to
simply continue running until it hits a breakpoint, catches a signal that
GDB is listening for, or exits. This is the case even if you set a catchpoint
for the exception; catchpoints on exceptions are disabled within interactive
calls.
-
You cannot raise an exception
interactively.
-
You cannot install an exception
handler interactively.
Sometimes catch
is not the best way to debug exception handling: if you need to know exactly
where an exception is raised, it is better to stop before the exception
handler is called, since that way you can see the stack before any unwinding
takes place. If you set a breakpoint in an exception handler instead, it
may not be easy to find out where the exception was raised.
To stop just before an exception
handler is called, you need some knowledge of the implementation. In the
case of GNU C++, exceptions are raised by calling a library function named
__raise_exception which has
the following ANSI C interface:
/* addr is where the exception identifier
is stored.
id is the exception identifier.
*/
void __raise_exception (void ** addr, void
* id);
To make the debugger
catch all exceptions before any stack unwinding takes place, set a breakpoint
on __raise_exception (see
Breakpoints, watchpoints,
and exceptions).
With a conditional breakpoint
(see Break conditions) that depends
on the value of id,
you can stop your program when a specific exception is raised. You can
use multiple conditional breakpoints to stop your program when any of a
number of exceptions are raised.