@cindex non-stop mode
@c This section is really only a place-holder, and needs to be expanded
-@c with more details.
+@c with more details.
For some multi-threaded targets, @value{GDBN} supports an optional
mode of operation in which you can examine stopped program threads in
the debugger while other threads continue to execute freely. This
-minimizes intrusion when debugging live systems, such as programs
-where some threads have real-time constraints or must continue to
+minimizes intrusion when debugging live systems, such as programs
+where some threads have real-time constraints or must continue to
respond to external events. This is referred to as @dfn{non-stop} mode.
In non-stop mode, when a thread stops to report a debugging event,
execution commands such as @code{continue} and @code{step} apply by default
only to the current thread in non-stop mode, rather than all threads as
in all-stop mode. This allows you to control threads explicitly in
-ways that are not possible in all-stop mode --- for example, stepping
+ways that are not possible in all-stop mode --- for example, stepping
one thread while allowing others to run freely, stepping
-one thread while holding all others stopped, or stepping several threads
+one thread while holding all others stopped, or stepping several threads
independently and simultaneously.
To enter non-stop mode, use this sequence of commands before you run
or attach to your program:
@smallexample
-# Enable the async interface.
+# Enable the async interface.
set target-async 1
# If using the CLI, pagination breaks non-stop.
@end table
Note these commands only reflect whether non-stop mode is enabled,
-not whether the currently-executing program is being run in non-stop mode.
+not whether the currently-executing program is being run in non-stop mode.
In particular, the @code{set non-stop} preference is only consulted when
-@value{GDBN} starts or connects to the target program, and it is generally
+@value{GDBN} starts or connects to the target program, and it is generally
not possible to switch modes once debugging has started. Furthermore,
since not all targets support non-stop mode, even when you have enabled
non-stop mode, @value{GDBN} may still fall back to all-stop operation by
default.
In non-stop mode, all execution commands apply only to the current thread
-by default. That is, @code{continue} only continues one thread.
+by default. That is, @code{continue} only continues one thread.
To continue all threads, issue @code{continue -a} or @code{c -a}.
-You can use @value{GDBN}'s background execution commands
+You can use @value{GDBN}'s background execution commands
(@pxref{Background Execution}) to run some threads in the background
-while you continue to examine or step others from @value{GDBN}.
+while you continue to examine or step others from @value{GDBN}.
The MI execution commands (@pxref{GDB/MI Program Execution}) are
always executed asynchronously in non-stop mode.
Suspending execution is done with the @code{interrupt} command when
-running in the background, or @kbd{Ctrl-c} during foreground execution.
-In all-stop mode, this stops the whole process;
-but in non-stop mode the interrupt applies only to the current thread.
+running in the background, or @kbd{Ctrl-c} during foreground execution.
+In all-stop mode, this stops the whole process;
+but in non-stop mode the interrupt applies only to the current thread.
To stop the whole program, use @code{interrupt -a}.
Other execution commands do not currently support the @code{-a} option.
In non-stop mode, when a thread stops, @value{GDBN} doesn't automatically make
that thread current, as it does in all-stop mode. This is because the
-thread stop notifications are asynchronous with respect to @value{GDBN}'s
+thread stop notifications are asynchronous with respect to @value{GDBN}'s
command interpreter, and it would be confusing if @value{GDBN} unexpectedly
changed to a different thread just as you entered a command to operate on the
previously current thread.
@value{GDBN}'s execution commands have two variants: the normal
foreground (synchronous) behavior, and a background
-(asynchronous) behavior. In foreground execution, @value{GDBN} waits for
+(asynchronous) behavior. In foreground execution, @value{GDBN} waits for
the program to report that some thread has stopped before prompting for
another command. In background execution, @value{GDBN} immediately gives
a command prompt so that you can issue other commands while your program runs.
@item interrupt
@itemx interrupt -a
-Suspend execution of the running program. In all-stop mode,
+Suspend execution of the running program. In all-stop mode,
@code{interrupt} stops the whole process, but in non-stop mode, it stops
-only the current thread. To stop the whole program in non-stop mode,
+only the current thread. To stop the whole program in non-stop mode,
use @code{interrupt -a}.
@end table
projects / binutils-gdb.git / commitdiff