* gdb.texinfo (Non-Stop Mode): Remove trailing whitespace.

	(Background Execution): Ditto.

2 files changed, 23 insertions, 18 deletions

diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog
index 5095018..156b2c9 100644
--- a/gdb/doc/ChangeLog
+++ b/gdb/doc/ChangeLog
@@ -1,3 +1,8 @@
+2014-03-30  Doug Evans  <dje@google.com>
+
+	* gdb.texinfo (Non-Stop Mode): Remove trailing whitespace.
+	(Background Execution): Ditto.
+
 2014-03-21  Pedro Alves  <palves@redhat.com>
 	    Stan Shebs  <stan@codesourcery.com>
 	    Hui Zhu  <hui@codesourcery.com>
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 1df3ca0..0bf33b7 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -5701,13 +5701,13 @@ multiple processes.
 @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,
@@ -5716,16 +5716,16 @@ threads as well, in contrast to the all-stop mode behavior.  Additionally,
 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.
@@ -5749,35 +5749,35 @@ Show the current non-stop enablement setting.
 @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.
@@ -5792,7 +5792,7 @@ 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.
@@ -5874,9 +5874,9 @@ using the @code{interrupt} command.
 @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