From: Roland Pesch <pesch@cygnus>
Date: Wed, 26 Jan 1994 23:35:17 +0000 (+0000)
Subject: General editing pass prior to Net release.
X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=9a27b06e9823be3f762f9b87bd936e5e22359e9b;p=binutils-gdb.git

General editing pass prior to Net release.
---

diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog
index 00f11a56484..72b50d97697 100644
--- a/gdb/doc/ChangeLog
+++ b/gdb/doc/ChangeLog
@@ -1,3 +1,7 @@
+Wed Jan 26 15:31:57 1994  Roland H. Pesch  (pesch@fowanton.cygnus.com)
+
+	* gdb.texinfo, remote.texi: general editing pass prior to Net release
+
 Tue Jan 25 12:12:04 1994  Jim Kingdon  (kingdon@lioth.cygnus.com)
 
 	* stabs.texinfo (String Field): Discuss continuing stabs with ?.
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 13f0c77ae0f..d3e946b27ca 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -29,10 +29,10 @@
 @syncodeindex vr cp
 
 @c !!set GDB manual's edition---not the same as GDB version!
-@set EDITION 4.11
+@set EDITION 4.12
 
 @c !!set GDB manual's revision date
-@set DATE November 1993
+@set DATE January 1994
 
 @c GDB CHANGELOG CONSULTED BETWEEN:
 @c Fri Oct 11 23:27:06 1991  John Gilmore  (gnu at cygnus.com)
@@ -274,7 +274,7 @@ omitted from this list, we would like to add your names!
 
 So that they may not regard their long labor as thankless, we
 particularly thank those who shepherded GDB through major releases: Fred
-Fish (releases 4.11, 4.10, 4.9), Stu Grossman and John Gilmore (releases
+Fish (releases 4.12, 4.11, 4.10, 4.9), Stu Grossman and John Gilmore (releases
 4.8, 4.7, 4.6, 4.5, 4.4), John Gilmore (releases 4.3, 4.2, 4.1, 4.0, and
 3.9); Jim Kingdon (releases 3.5, 3.4, 3.3); and Randy Smith (releases
 3.2, 3.1, 3.0).  As major maintainer of GDB for some period, each
@@ -489,10 +489,10 @@ GDB @value{GDBVN}, Copyright 1993 Free Software Foundation, Inc...
 @end smallexample
 
 @noindent
-@value{GDBN} reads only enough symbol data to know where to find the rest when
-needed; as a result, the first prompt comes up very quickly.  We now
-tell @value{GDBN} to use a narrower display width than usual, so that examples
-will fit in this manual.
+@value{GDBN} reads only enough symbol data to know where to find the
+rest when needed; as a result, the first prompt comes up very quickly.
+We now tell @value{GDBN} to use a narrower display width than usual, so
+that examples fit in this manual.
 
 @smallexample
 (@value{GDBP}) @b{set width 70}
@@ -581,7 +581,7 @@ stack frame for each active subroutine.
 @end smallexample
 
 @noindent
-We will step through a few more lines to see what happens.  The first two
+We step through a few more lines to see what happens.  The first two
 times, we can use @samp{s}; the next two times we use @code{n} to avoid
 falling into the @code{xstrdup} subroutine.
 
@@ -897,9 +897,9 @@ If memory-mapped files are available on your system through the @code{mmap}
 system call, you can use this option 
 to have @value{GDBN} write the symbols from your
 program into a reusable file in the current directory.  If the program you are debugging is
-called @file{/tmp/fred}, the mapped symbol file will be @file{./fred.syms}.
-Future @value{GDBN} debugging sessions will notice the presence of this file,
-and will quickly map in symbol information from it, rather than reading
+called @file{/tmp/fred}, the mapped symbol file is @file{./fred.syms}.
+Future @value{GDBN} debugging sessions notice the presence of this file,
+and can quickly map in symbol information from it, rather than reading
 the symbol table from the executable program.
 
 @c FIXME! Really host, not target?
@@ -1017,9 +1017,9 @@ an end-of-file character (usually @kbd{C-d}).
 @end table
 
 @cindex interrupt
-An interrupt (often @kbd{C-c}) will not exit from @value{GDBN}, but rather
-will terminate the action of any @value{GDBN} command that is in progress and
-return to @value{GDBN} command level.  It is safe to type the interrupt
+An interrupt (often @kbd{C-c}) does not exit from @value{GDBN}, but rather
+terminates the action of any @value{GDBN} command that is in progress and
+returns to @value{GDBN} command level.  It is safe to type the interrupt
 character at any time because @value{GDBN} does not allow it to take effect
 until a time when it is safe.
 
@@ -1097,7 +1097,7 @@ arguments to the @code{help} command.
 @kindex RET
 A blank line as input to @value{GDBN} (typing just @key{RET}) means to
 repeat the previous command. Certain commands (for example, @code{run})
-will not repeat this way; these are commands for which unintentional
+will not repeat this way; these are commands whose unintentional
 repetition might cause trouble and which you are unlikely to want to
 repeat.
 
@@ -1128,8 +1128,8 @@ are for the next word in a command, at any time.  This works for @value{GDBN}
 commands, @value{GDBN} subcommands, and the names of symbols in your program.
 
 Press the @key{TAB} key whenever you want @value{GDBN} to fill out the rest
-of a word.  If there is only one possibility, @value{GDBN} will fill in the
-word, and wait for you to finish the command (or press @key{RET} to
+of a word.  If there is only one possibility, @value{GDBN} fills in the
+word, and waits for you to finish the command (or press @key{RET} to
 enter it).  For example, if you type
 
 @c FIXME "@key" does not distinguish its argument sufficiently to permit
@@ -1157,12 +1157,12 @@ might as well just type @key{RET} immediately after @samp{info bre},
 to exploit command abbreviations rather than command completion).
 
 If there is more than one possibility for the next word when you press
-@key{TAB}, @value{GDBN} will sound a bell.  You can either supply more
-characters and try again, or just press @key{TAB} a second time, and
-@value{GDBN} will display all the possible completions for that word.  For
+@key{TAB}, @value{GDBN} sounds a bell.  You can either supply more
+characters and try again, or just press @key{TAB} a second time;
+@value{GDBN} displays all the possible completions for that word.  For
 example, you might want to set a breakpoint on a subroutine whose name
 begins with @samp{make_}, but when you type @kbd{b make_@key{TAB}} @value{GDBN}
-just sounds the bell.  Typing @key{TAB} again will display all the
+just sounds the bell.  Typing @key{TAB} again displays all the
 function names in your program that begin with those characters, for
 example:
 
@@ -1218,8 +1218,8 @@ bubble(double,double)    bubble(int,int)
 (@value{GDBP}) b 'bubble(
 @end example
 
-In some cases, @value{GDBN} can tell that completing a name will require
-quotes.  When this happens, @value{GDBN} will insert the quote for you (while
+In some cases, @value{GDBN} can tell that completing a name requires using
+quotes.  When this happens, @value{GDBN} inserts the quote for you (while
 completing as much as it can) if you do not type the quote in the first
 place:
 
@@ -1298,7 +1298,7 @@ Command name abbreviations are allowed if unambiguous.
 @end smallexample
 
 @item help @var{command}
-With a command name as @code{help} argument, @value{GDBN} will display a
+With a command name as @code{help} argument, @value{GDBN} displays a
 short paragraph on how to use that command.
 @end table
 
@@ -1413,10 +1413,10 @@ your luck.
 @cindex optimized code, debugging
 @cindex debugging optimized code
 When you debug a program compiled with @samp{-g -O}, remember that the
-optimizer is rearranging your code; the debugger will show you what is
+optimizer is rearranging your code; the debugger shows you what is
 really there.  Do not be too surprised when the execution path does not
 exactly match your source file!  An extreme example: if you define a
-variable, but never use it, @value{GDBN} will never see that
+variable, but never use it, @value{GDBN} never sees that
 variable---because the compiler optimizes it out of existence.
 
 Some things do not work as well with @samp{-g -O} as with just
@@ -1458,7 +1458,7 @@ that process run your program.  (In environments without processes,
 The execution of a program is affected by certain information it
 receives from its superior.  @value{GDBN} provides ways to specify this
 information, which you must do @emph{before} starting your program.  (You
-can change it after starting your program, but such changes will only affect
+can change it after starting your program, but such changes only affect
 your program the next time you start it.)  This information may be
 divided into four categories:
 
@@ -1475,7 +1475,7 @@ program's arguments}.
 @item The @emph{environment.}
 Your program normally inherits its environment from @value{GDBN}, but you can
 use the @value{GDBN} commands @code{set environment} and @code{unset
-environment} to change parts of the environment that will be given to
+environment} to change parts of the environment that affect
 your program.  @xref{Environment, ,Your program's environment}.
 
 @item The @emph{working directory.}
@@ -1504,10 +1504,10 @@ of how to arrange for your program to stop.  Once your program has
 stopped, you may call functions in your program, using the @code{print}
 or @code{call} commands.  @xref{Data, ,Examining Data}.
 
-If the modification time of your symbol file has changed since the
-last time @value{GDBN} read its symbols, @value{GDBN} will discard its symbol table and
-re-read it.  When it does this, @value{GDBN} tries to retain your current
-breakpoints.
+If the modification time of your symbol file has changed since the last
+time @value{GDBN} read its symbols, @value{GDBN} discards its symbol
+table, and reads it again.  When it does this, @value{GDBN} tries to retain
+your current breakpoints.
 
 @ifclear BARETARGET
 @node Arguments
@@ -1528,7 +1528,7 @@ shell @value{GDBN} if you do not define @code{SHELL}, @value{GDBN} uses
 @table @code
 @item set args
 Specify the arguments to be used the next time your program is run.  If
-@code{set args} has no arguments, @code{run} will execute your program
+@code{set args} has no arguments, @code{run} executes your program
 with no arguments.  Once you have run your program with arguments,
 using @code{set args} before the next @code{run} is the only way to run
 it again without arguments.
@@ -1557,7 +1557,7 @@ Add @var{directory} to the front of the @code{PATH} environment variable
 (the search path for executables), for both @value{GDBN} and your program.
 You may specify several directory names, separated by @samp{:} or
 whitespace.  If @var{directory} is already in the path, it is moved to
-the front, so it will be searched sooner.
+the front, so it is searched sooner.
 
 You can use the string @samp{$cwd} to refer to whatever is the current
 working directory at the time @value{GDBN} searches the path.  If you
@@ -1614,7 +1614,7 @@ rather than assigning it an empty value.
 by your @code{SHELL} environment variable if it exists (or
 @code{/bin/sh} if not).  If your @code{SHELL} variable names a shell
 that runs an initialization file---such as @file{.cshrc} for C-shell, or
-@file{.bashrc} for BASH---any variables you set in that file will affect
+@file{.bashrc} for BASH---any variables you set in that file affect
 your program.  You may wish to move setting of environment variables to
 files that are only run when you sign on, such as @file{.login} or
 @file{.profile}.
@@ -1705,12 +1705,12 @@ for @value{GDBN} still comes from your terminal.
 @table @code
 @item attach @var{process-id}
 This command attaches to a running process---one that was started
-outside @value{GDBN}.  (@code{info files} will show your active
+outside @value{GDBN}.  (@code{info files} shows your active
 targets.)  The command takes as argument a process ID.  The usual way to
 find out the process-id of a Unix process is with the @code{ps} utility,
 or with the @samp{jobs -l} shell command.
 
-@code{attach} will not repeat if you press @key{RET} a second time after
+@code{attach} does not repeat if you press @key{RET} a second time after
 executing the command.
 @end table
 
@@ -1739,15 +1739,16 @@ When you have finished debugging the attached process, you can use the
 the process continues its execution.  After the @code{detach} command,
 that process and @value{GDBN} become completely independent once more, and you
 are ready to @code{attach} another process or start one with @code{run}.
-@code{detach} will not repeat if you press @key{RET} again after
+@code{detach} does not repeat if you press @key{RET} again after
 executing the command.
 @end table
 
-If you exit @value{GDBN} or use the @code{run} command while you have an attached
-process, you kill that process.  By default, you will be asked for
-confirmation if you try to do either of these things; you can control
-whether or not you need to confirm by using the @code{set confirm} command
-(@pxref{Messages/Warnings, ,Optional warnings and messages}).
+If you exit @value{GDBN} or use the @code{run} command while you have an
+attached process, you kill that process.  By default, @value{GDBN} asks
+for confirmation if you try to do either of these things; you can
+control whether or not you need to confirm by using the @code{set
+confirm} command (@pxref{Messages/Warnings, ,Optional warnings and
+messages}).
 
 @node Kill Process
 @c @group
@@ -1772,8 +1773,8 @@ outside the debugger.
 The @code{kill} command is also useful if you wish to recompile and
 relink your program, since on many systems it is impossible to modify an
 executable file while it is running in a process.  In this case, when you
-next type @code{run}, @value{GDBN} will notice that the file has changed, and
-will re-read the symbol table (while trying to preserve your current
+next type @code{run}, @value{GDBN} notices that the file has changed, and
+reads the symbol table again (while trying to preserve your current
 breakpoint settings).
 
 @node Process Information
@@ -2031,8 +2032,8 @@ and why it stopped.
 
 @cindex breakpoints
 A @dfn{breakpoint} makes your program stop whenever a certain point in
-the program is reached.  For each breakpoint, you can add various
-conditions to control in finer detail whether your program will stop.
+the program is reached.  For each breakpoint, you can add
+conditions to control in finer detail whether your program stops.
 You can set breakpoints with the @code{break} command and its variants
 (@pxref{Set Breaks, ,Setting breakpoints}), to specify the place where
 your program should stop by line number, function name or exact address
@@ -2123,7 +2124,7 @@ at which execution stopped in the currently selected frame.
 @item break @var{linenum}
 Set a breakpoint at line @var{linenum} in the current source file.
 That file is the last file whose source text was printed.  This
-breakpoint will stop your program just before it executes any of the
+breakpoint stops your program just before it executes any of the
 code on that line.
 
 @item break @var{filename}:@var{linenum}
@@ -2144,11 +2145,11 @@ information or source files.
 When called without any arguments, @code{break} sets a breakpoint at
 the next instruction to be executed in the selected stack frame
 (@pxref{Stack, ,Examining the Stack}).  In any selected frame but the
-innermost, this will cause your program to stop as soon as control
+innermost, this makes your program stop as soon as control
 returns to that frame.  This is similar to the effect of a
 @code{finish} command in the frame inside the selected frame---except
 that @code{finish} does not leave an active breakpoint.  If you use
-@code{break} without an argument in the innermost frame, @value{GDBN} will stop
+@code{break} without an argument in the innermost frame, @value{GDBN} stops
 the next time it reaches the current location; this may be useful
 inside loops.
 
@@ -2286,9 +2287,18 @@ where this may happen.
 
 Watchpoints currently execute two orders of magnitude more slowly than
 other breakpoints, but this can be well worth it to catch errors where
-you have no clue what part of your program is the culprit.  Some
-processors provide special hardware to support watchpoint evaluation; future
-releases of @value{GDBN} will use such hardware if it is available.
+you have no clue what part of your program is the culprit.
+
+@ignore
+@c this "future releases" promise has been in too long, is getting
+@c embarrassing.  But...
+@c FIXME: in future updates, check whether hardware watchpoints in on any
+@c platforms yet.  As of 26jan94, they're very close on HPPA running
+@c Berkeley and on Irix 4.
+Some processors provide special hardware to support watchpoint
+evaluation; future releases of @value{GDBN} will use such hardware if it
+is available.
+@end ignore
 
 @table @code
 @kindex watch
@@ -2309,8 +2319,8 @@ same as @code{info break}.
 usefulness.  With the current watchpoint implementation, @value{GDBN}
 can only watch the value of an expression @emph{in a single thread}.  If
 you are confident that the expression can only change due to the current
-thread's activity (and if you are also confident that the same thread
-will remain current), then you can use watchpoints as usual.  However,
+thread's activity (and if you are also confident that no other thread
+can become current), then you can use watchpoints as usual.  However,
 @value{GDBN} may not notice when a non-current thread's activity changes
 the expression.
 @end quotation
@@ -2337,8 +2347,7 @@ to catch.
 You can use @code{info catch} to list active exception handlers.
 @xref{Frame Info, ,Information about a frame}.
 
-There are currently some limitations to exception handling in @value{GDBN}.
-These will be corrected in a future release.
+There are currently some limitations to exception handling in @value{GDBN}:
 
 @itemize @bullet
 @item
@@ -2348,10 +2357,12 @@ raises an exception, however, the call may bypass the mechanism that
 returns control to you and cause your program to simply continue
 running until it hits a breakpoint, catches a signal that @value{GDBN} is
 listening for, or exits.
+
 @item
 You cannot raise an exception interactively.
+
 @item
-You cannot interactively install an exception handler.
+You cannot install an exception handler interactively.
 @end itemize
 
 @cindex raise exceptions
@@ -2451,17 +2462,17 @@ enablement:
 
 @itemize @bullet
 @item
-Enabled.  The breakpoint will stop your program.  A breakpoint set
+Enabled.  The breakpoint stops your program.  A breakpoint set
 with the @code{break} command starts out in this state.
 @item
 Disabled.  The breakpoint has no effect on your program.
 @item
-Enabled once.  The breakpoint will stop your program, but
-when it does so it will become disabled.  A breakpoint set
-with the @code{tbreak} command starts out in this state.
+Enabled once.  The breakpoint stops your program, but then becomes
+disabled.  A breakpoint set with the @code{tbreak} command starts out in
+this state.
 @item
-Enabled for deletion.  The breakpoint will stop your program, but
-immediately after it does so it will be deleted permanently.
+Enabled for deletion.  The breakpoint stops your program, but
+immediately after it does so it is deleted permanently.
 @end itemize
 
 You can use the following commands to enable or disable breakpoints and
@@ -2485,19 +2496,19 @@ Enable the specified breakpoints (or all defined breakpoints).  They
 become effective once again in stopping your program.
 
 @item enable @r{[}breakpoints@r{]} once @var{bnums}@dots{}
-Enable the specified breakpoints temporarily.  Each will be disabled
-again the next time it stops your program.
+Enable the specified breakpoints temporarily.  @value{GDBN} disables any
+of these breakpoints immediately after stopping your program.
 
 @item enable @r{[}breakpoints@r{]} delete @var{bnums}@dots{}
-Enable the specified breakpoints to work once and then die.  Each of
-the breakpoints will be deleted the next time it stops your program.
+Enable the specified breakpoints to work once, then die.  @value{GDBN}
+deletes any of these breakpoints as soon as your program stops there.
 @end table
 
 Save for a breakpoint set with @code{tbreak} (@pxref{Set Breaks,
 ,Setting breakpoints}), breakpoints that you set are initially enabled;
 subsequently, they become disabled or enabled only when you use one of
 the commands above.  (The command @code{until} can set and delete a
-breakpoint of its own, but it will not change the state of your other
+breakpoint of its own, but it does not change the state of your other
 breakpoints; see @ref{Continuing and Stepping, ,Continuing and
 stepping}.)
 
@@ -2549,11 +2560,12 @@ impose a further condition on a watchpoint.
 @item condition @var{bnum} @var{expression}
 @kindex condition
 Specify @var{expression} as the break condition for breakpoint or
-watchpoint number @var{bnum}.  From now on, this breakpoint will stop
-your program only if the value of @var{expression} is true (nonzero, in
-C).  When you use @code{condition}, @value{GDBN} checks @var{expression}
-immediately for syntactic correctness, and to determine whether symbols
-in it have referents in the context of your breakpoint.
+watchpoint number @var{bnum}.  After you set a condition, breakpoint
+@var{bnum} stops your program only if the value of @var{expression} is
+true (nonzero, in C).  When you use @code{condition}, @value{GDBN}
+checks @var{expression} immediately for syntactic correctness, and to
+determine whether symbols in it have referents in the context of your
+breakpoint.
 @c FIXME so what does GDB do if there is no referent?  Moreover, what
 @c about watchpoints?
 @value{GDBN} does
@@ -2574,15 +2586,15 @@ is an integer.  Most of the time, the ignore count is zero, and
 therefore has no effect.  But if your program reaches a breakpoint whose
 ignore count is positive, then instead of stopping, it just decrements
 the ignore count by one and continues.  As a result, if the ignore count
-value is @var{n}, the breakpoint will not stop the next @var{n} times it
-is reached.
+value is @var{n}, the breakpoint does not stop the next @var{n} times
+your program reaches it.
 
 @table @code
 @item ignore @var{bnum} @var{count}
 @kindex ignore
 Set the ignore count of breakpoint number @var{bnum} to @var{count}.
 The next @var{count} times the breakpoint is reached, your program's
-execution will not stop; other than to decrement the ignore count, @value{GDBN}
+execution does not stop; other than to decrement the ignore count, @value{GDBN}
 takes no action.
 
 To make the breakpoint stop the next time it is reached, specify
@@ -2593,9 +2605,9 @@ breakpoint, you can specify an ignore count directly as an argument to
 @code{continue}, rather than using @code{ignore}.  @xref{Continuing and
 Stepping,,Continuing and stepping}.
 
-If a breakpoint has a positive ignore count and a condition, the condition
-is not checked.  Once the ignore count reaches zero, the condition will
-be checked.
+If a breakpoint has a positive ignore count and a condition, the
+condition is not checked.  Once the ignore count reaches zero,
+@value{GDBN} resumes checking the condition.
 
 You could achieve the effect of the ignore count with a condition such
 as @w{@samp{$foo-- <= 0}} using a debugger convenience variable that
@@ -2648,7 +2660,7 @@ If the first command you specify in a command list is @code{silent}, the
 usual message about stopping at a breakpoint is not printed.  This may
 be desirable for breakpoints that are to print a specific message and
 then continue.  If none of the remaining commands print anything, you
-will see no sign that the breakpoint was reached.  @code{silent} is
+see no sign that the breakpoint was reached.  @code{silent} is
 meaningful only at the beginning of a breakpoint command list.
 
 The commands @code{echo}, @code{output}, and @code{printf} allow you to
@@ -2694,7 +2706,7 @@ Some programming languages (notably C++) permit a single function name
 to be defined several times, for application in different contexts.
 This is called @dfn{overloading}.  When a function name is overloaded,
 @samp{break @var{function}} is not enough to tell @value{GDBN} where you want
-a breakpoint.  If you realize this will be a problem, you can use
+a breakpoint.  If you realize this is a problem, you can use
 something like @samp{break @var{function}(@var{types})} to specify which
 particular version of the function you want.  Otherwise, @value{GDBN} offers
 you a menu of numbered choices for different possible breakpoints, and
@@ -2884,10 +2896,10 @@ automatically continues execution until the program counter is greater
 than the address of the jump.
 
 This means that when you reach the end of a loop after single stepping
-though it, @code{until} will cause your program to continue execution
-until the loop is exited.  In contrast, a @code{next} command at the end
-of a loop will simply step back to the beginning of the loop, which
-would force you to step through the next iteration.
+though it, @code{until} makes your program continue execution until it
+exits the loop.  In contrast, a @code{next} command at the end of a loop
+simply steps back to the beginning of the loop, which forces you to step
+through the next iteration.
 
 @code{until} always stops your program if it attempts to exit the current
 stack frame.
@@ -2933,9 +2945,9 @@ and hence is quicker than @code{until} without an argument.
 Execute one machine instruction, then stop and return to the debugger.
 
 It is often useful to do @samp{display/i $pc} when stepping by machine
-instructions.  This will cause the next instruction to be executed to
-be displayed automatically at each stop.  @xref{Auto Display,
-,Automatic display}.
+instructions.  This makes @value{GDBN} automatically display the next
+instruction to be executed, each time your program stops.  @xref{Auto
+Display,, Automatic display}.
 
 An argument is a repeat count, as in @code{step}.
 
@@ -3017,8 +3029,8 @@ the @code{print} keyword as well.
 implies the @code{nostop} keyword as well.
 
 @item pass
-@value{GDBN} should allow your program to see this signal; your program will be
-able to handle the signal, or may be terminated if the signal is fatal
+@value{GDBN} should allow your program to see this signal; your program
+can handle the signal, or else it may terminate if the signal is fatal
 and not handled.
 
 @item nopass
@@ -3027,11 +3039,11 @@ and not handled.
 @c @end group
 
 When a signal stops your program, the signal is not visible until you
-continue.  Your program will see the signal then, if @code{pass} is in
+continue.  Your program sees the signal then, if @code{pass} is in
 effect for the signal in question @emph{at that time}.  In other words,
 after @value{GDBN} reports a signal, you can use the @code{handle}
-command with @code{pass} or @code{nopass} to control whether that
-signal will be seen by your program when you later continue it.
+command with @code{pass} or @code{nopass} to control whether your
+program sees that signal when you continue.
 
 You can also use the @code{signal} command to prevent your program from
 seeing a signal, or cause it to see a signal it normally would not see,
@@ -3186,11 +3198,11 @@ frames in @value{GDBN} commands.
 @cindex frameless execution
 Some compilers provide a way to compile functions so that they operate
 without stack frames.  (For example, the @code{@value{GCC}} option
-@samp{-fomit-frame-pointer} will generate functions without a frame.)
+@samp{-fomit-frame-pointer} generates functions without a frame.)
 This is occasionally done with heavily used library functions to save
 the frame setup time.  @value{GDBN} has limited facilities for dealing
 with these function invocations.  If the innermost function invocation
-has no stack frame, @value{GDBN} will nevertheless regard it as though
+has no stack frame, @value{GDBN} nevertheless regards it as though
 it had a separate frame, which is numbered zero as usual, allowing
 correct tracing of the function call chain.  However, @value{GDBN} has
 no provision for frameless functions elsewhere in the stack.
@@ -3322,8 +3334,8 @@ For example:
 @end group
 @end smallexample
 
-After such a printout, the @code{list} command with no arguments will
-print ten lines centered on the point of execution in the frame.
+After such a printout, the @code{list} command with no arguments
+prints ten lines centered on the point of execution in the frame.
 @xref{List, ,Printing source lines}.
 
 @table @code
@@ -3499,8 +3511,7 @@ the @code{list} argument explicitly specifies some other number).
 
 @item show listsize
 @kindex show listsize
-Display the number of lines that @code{list} will currently display by
-default.
+Display the number of lines that @code{list} prints.
 @end table
 
 Repeating a @code{list} command with @key{RET} discards the argument,
@@ -3620,13 +3631,13 @@ the executable search path is @emph{not} used for this purpose.  Neither is
 the current working directory, unless it happens to be in the source
 path.
 
-If @value{GDBN} cannot find a source file in the source path, and the object
-program records a directory, @value{GDBN} tries that directory too.  If the
-source path is empty, and there is no record of the compilation
-directory, @value{GDBN} will, as a last resort, look in the current
-directory.
+If @value{GDBN} cannot find a source file in the source path, and the
+object program records a directory, @value{GDBN} tries that directory
+too.  If the source path is empty, and there is no record of the
+compilation directory, @value{GDBN} looks in the current directory as a
+last resort.
 
-Whenever you reset or rearrange the source path, @value{GDBN} will clear out
+Whenever you reset or rearrange the source path, @value{GDBN} clears out
 any information it has cached about where source files are found and where
 each line is in the file.
 
@@ -3639,7 +3650,7 @@ To add other directories, use the @code{directory} command.
 Add directory @var{dirname} to the front of the source path.  Several
 directory names may be given to this command, separated by @samp{:} or
 whitespace.  You may specify a directory that is already in the source
-path; this moves it forward, so it will be searched sooner.
+path; this moves it forward, so @value{GDBN} searches it sooner.
 
 @kindex cdir
 @kindex cwd
@@ -3733,9 +3744,9 @@ variables}).
 This specialized command dumps a range of memory as machine
 instructions.  The default memory range is the function surrounding the
 program counter of the selected frame.  A single argument to this
-command is a program counter value; the function surrounding this value
-will be dumped.  Two arguments specify a range of addresses (first
-inclusive, second exclusive) to dump.
+command is a program counter value; @value{GDBN} dumps the function
+surrounding this value.  Two arguments specify a range of addresses
+(first inclusive, second exclusive) to dump.
 @end table
 
 @ifclear H8EXCLUSIVE
@@ -4069,9 +4080,10 @@ used with the @code{x} command, where @samp{b} stands for ``byte'';
 @pxref{Memory,,Examining memory}.}
 
 @item a
-Print as an address, both absolute in hex and as an offset from the
-nearest preceding symbol.  This format can be used to discover where (in
-what function) an unknown address is located:
+@cindex unknown address, locating
+Print as an address, both absolute in hexadecimal and as an offset from
+the nearest preceding symbol.  You can use this format used to discover
+where (in what function) an unknown address is located:
 
 @example
 (@value{GDBP}) p/a 0x54320
@@ -4172,9 +4184,9 @@ words (@samp{w}) of memory above the stack pointer (here, @samp{$sp};
 
 Since the letters indicating unit sizes are all distinct from the
 letters specifying output formats, you do not have to remember whether
-unit size or format comes first; either order will work.  The output
+unit size or format comes first; either order works.  The output
 specifications @samp{4xw} and @samp{4wx} mean exactly the same thing.
-(However, the count @var{n} must come first; @samp{wx4} will not work.)
+(However, the count @var{n} must come first; @samp{wx4} does not work.)
 
 Even though the unit size @var{u} is ignored for the formats @samp{s}
 and @samp{i}, you might still want to use a count @var{n}; for example,
@@ -4212,7 +4224,7 @@ address printed if several units were printed on the last line of output.
 
 If you find that you want to print the value of an expression frequently
 (to see how it changes), you might want to add it to the @dfn{automatic
-display list} so that @value{GDBN} will print its value each time your program stops.
+display list} so that @value{GDBN} prints its value each time your program stops.
 Each expression added to the list is given a number to identify it;
 to remove an expression from the list, you specify that number.
 The automatic display looks like this:
@@ -4237,7 +4249,7 @@ supported by @code{x}; otherwise it uses @code{print}.
 Add the expression @var{exp} to the list of expressions to display
 each time your program stops.  @xref{Expressions, ,Expressions}.
 
-@code{display} will not repeat if you press @key{RET} again after using it.
+@code{display} does not repeat if you press @key{RET} again after using it.
 
 @item display/@var{fmt} @var{exp}
 For @var{fmt} specifying only a display format and not a size or
@@ -4263,7 +4275,7 @@ is a common name for the program counter; @pxref{Registers}).
 @kindex undisplay
 Remove item numbers @var{dnums} from the list of expressions to display.
 
-@code{undisplay} will not repeat if you press @key{RET} after using it.
+@code{undisplay} does not repeat if you press @key{RET} after using it.
 (Otherwise you would just get the error @samp{No display number @dots{}}.)
 
 @item disable display @var{dnums}@dots{}
@@ -4295,11 +4307,11 @@ sense outside the lexical context for which it was set up.  Such an
 expression is disabled when execution enters a context where one of its
 variables is not defined.  For example, if you give the command
 @code{display last_char} while inside a function with an argument
-@code{last_char}, then this argument will be displayed while your program
+@code{last_char}, @value{GDBN} displays this argument while your program
 continues to stop inside that function.  When it stops elsewhere---where
-there is no variable @code{last_char}---display is disabled.  The next time
-your program stops where @code{last_char} is meaningful, you can enable the
-display expression once again.
+there is no variable @code{last_char}---the display is disabled
+automatically.  The next time your program stops where @code{last_char}
+is meaningful, you can enable the display expression once again.
 
 @node Print Settings
 @section Print settings
@@ -4316,10 +4328,10 @@ These settings are useful for debugging programs in any language:
 @item set print address
 @itemx set print address on
 @kindex set print address
-@value{GDBN} will print memory addresses showing the location of stack
+@value{GDBN} prints memory addresses showing the location of stack
 traces, structure values, pointer values, breakpoints, and so forth,
 even when it also displays the contents of those addresses.  The default
-is on.  For example, this is what a stack frame display looks like, with
+is @code{on}.  For example, this is what a stack frame display looks like, with
 @code{set print address on}:
 
 @smallexample
@@ -4358,7 +4370,7 @@ When @value{GDBN} prints a symbolic address, it normally prints the
 closest earlier symbol plus an offset.  If that symbol does not uniquely
 identify the address (for example, it is a name whose scope is a single
 source file), you may need to disambiguate.  One way to do this is with
-@code{info line}, for example @code{info line *0x4537}.  Alternately,
+@code{info line}, for example @samp{info line *0x4537}.  Alternately,
 you can set @value{GDBN} to print the source file and line number when
 it prints a symbolic address:
 
@@ -4378,17 +4390,10 @@ Show whether or not @value{GDBN} will print the source file name and
 line number of a symbol in the symbolic form of an address.
 @end table
 
-Another situation where it's helpful to show symbol filenames and line
-numbers is when disassembling code; @value{GDBN} will show you the line
+Another situation where it is helpful to show symbol filenames and line
+numbers is when disassembling code; @value{GDBN} shows you the line
 number and source file that corresponds to each instruction.
 
-If you have a pointer and you aren't sure what object it points to,
-you can turn on printing of symbolic addresses and filenames, and
-determine the name and source file location of the variable which
-is being pointed to, using the @code{x/x @var{pointer}} command.
-This displays the memory location pointed to, and as a side effect,
-interprets the address in symbolic form.
-
 Also, you may wish to see the symbolic form only if the address being
 printed is reasonably close to the closest earlier symbol:
 
@@ -4402,7 +4407,7 @@ symbolic form of an address, if any symbol precedes it.
 
 @item show print max-symbolic-offset
 @kindex show print max-symbolic-offset
-Ask how large the maximum offset is that @value{GDBN} will print in a
+Ask how large the maximum offset is that @value{GDBN} prints in a
 symbolic address.
 @end table
 
@@ -4410,14 +4415,14 @@ Sometimes @value{GDBN} can tell you more about an address if it does an
 extensive search of its symbol information.  The default is to provide
 a quick symbolic display that is usually correct, but which may not give
 the most useful answer when working in some object file formats.  If
-you aren't getting the information you need, try:
+you are not getting the information you need, try:
 
 @table @code
 @item set print fast-symbolic-addr off
 @kindex set print fast-symbolic-addr
-Search all symbolic information when displaying an address symbolically.
+Search all symbol information when displaying an address symbolically.
 This setting may display more information about static variables, for
-example, but will take longer.
+example, but also takes longer.
 
 @item set print fast-symbolic-addr
 @item set print fast-symbolic-addr on
@@ -4426,17 +4431,40 @@ information about an address.  This is the default.
 
 @item show print fast-symbolic-addr
 @kindex show print fast-symbolic-addr
-Ask whether @value{GDBN} will use a fast or slow method of printing
+Ask whether @value{GDBN} is using a fast or slow method of printing
 symbolic address.
 @end table
 
+@cindex wild pointer, interpreting
+@cindex pointer, finding referent
+If you have a pointer and you are not sure where it points, try
+@samp{set print symbol-filename on} and @samp{set print
+fast-symbolic-addr off}.  Then you can determine the name and source
+file location of the variable where it points, using @samp{p/a
+@var{pointer}}.  This interprets the address in symbolic form.  For
+example, here @value{GDBN} shows that a variable @code{ptt} points at
+another variable @code{t}, defined in @file{hi2.c}:
+
+@example
+(@value{GDBP}) set print fast-symbolic-addr off
+(@value{GDBP}) set print symbol-filename on
+(@value{GDBP}) p/a ptt
+$4 = 0xe008 <t in hi2.c>
+@end example
+
+@quotation
+@emph{Warning:} For pointers that point to a local variable, @samp{p/a}
+does not show the symbol name and filename of the referent, even with
+the appropriate @code{set print} options turned on.
+@end quotation
+
 Other settings control how different kinds of objects are printed:
 
 @table @code
 @item set print array
 @itemx set print array on
 @kindex set print array
-@value{GDBN} will pretty-print arrays.  This format is more convenient to read,
+Pretty-print arrays.  This format is more convenient to read,
 but uses more space.  The default is off.
 
 @item set print array off
@@ -4449,14 +4477,14 @@ arrays.
 
 @item set print elements @var{number-of-elements}
 @kindex set print elements
-If @value{GDBN} is printing a large array, it will stop printing after it has
+If @value{GDBN} is printing a large array, it stops printing after it has
 printed the number of elements set by the @code{set print elements} command.
 This limit also applies to the display of strings.
 Setting the number of elements to zero means that the printing is unlimited.
 
 @item show print elements
 @kindex show print elements
-Display the number of elements of a large array that @value{GDBN} will print
+Display the number of elements of a large array that @value{GDBN} prints
 before losing patience.
 
 @item set print pretty on
@@ -4492,23 +4520,23 @@ This is the default format.
 
 @item show print pretty
 @kindex show print pretty
-Show which format @value{GDBN} will use to print structures.
+Show which format @value{GDBN} is using to print structures.
 
 @item set print sevenbit-strings on
 @kindex set print sevenbit-strings
 Print using only seven-bit characters; if this option is set,
-@value{GDBN} will display any eight-bit characters (in strings or character
-values) using the notation @code{\}@var{nnn}.  This setting is best when
-working in English (ASCII) and the high-order bit of characters is used
-as a marker or ``meta'' bit.
+@value{GDBN} displays any eight-bit characters (in strings or
+character values) using the notation @code{\}@var{nnn}.  This setting is
+best if you are working in English (@sc{ascii}) and you use the
+high-order bit of characters as a marker or ``meta'' bit.
 
 @item set print sevenbit-strings off
-Print full eight-bit characters.  This
-allows the use of full international character sets, and is the default.
+Print full eight-bit characters.  This allows the use of more
+international character sets, and is the default.
 
 @item show print sevenbit-strings
 @kindex show print sevenbit-strings
-Show whether or not @value{GDBN} will print only seven-bit characters.
+Show whether or not @value{GDBN} is printing only seven-bit characters.
 
 @item set print union on
 @kindex set print union
@@ -4572,7 +4600,7 @@ linkage.  The default is @samp{on}.
 
 @item show print demangle
 @kindex show print demangle
-Show whether C++ names will be printed in mangled or demangled form.
+Show whether C++ names are printed in mangled or demangled form.
 
 @item set print asm-demangle
 @itemx set print asm-demangle on
@@ -4583,7 +4611,7 @@ The default is off.
 
 @item show print asm-demangle
 @kindex show print asm-demangle
-Show whether C++ names in assembly listings will be printed in mangled
+Show whether C++ names in assembly listings are printed in mangled
 or demangled form.
 
 @item set demangle-style @var{style}
@@ -4627,7 +4655,7 @@ virtual function table.  This is the default setting.
 
 @item show print object
 @kindex show print object
-Show whether actual, or declared, object types will be displayed.
+Show whether actual, or declared, object types are displayed.
 
 @item set print vtbl
 @itemx set print vtbl on
@@ -4889,7 +4917,7 @@ frame (with @samp{frame 0}).
 However, @value{GDBN} must deduce where registers are saved, from the machine
 code generated by your compiler.  If some registers are not saved, or if
 @value{GDBN} is unable to locate the saved registers, the selected stack
-frame will make no difference.
+frame makes no difference.
 
 @ifset AMD29K
 @table @code
@@ -4904,7 +4932,7 @@ enough''.  This may result in @value{GDBN} referencing memory locations that
 do not exist.  If necessary, you can get around this problem by
 specifying the ending address of the register stack with the @code{set
 rstack_high_address} command.  The argument should be an address, which
-you will probably want to precede with @samp{0x} to specify in
+you probably want to precede with @samp{0x} to specify in
 hexadecimal.
 
 @item show rstack_high_address
@@ -5062,7 +5090,7 @@ case frees you from having to set the working language manually.
 @node Show
 @section Displaying the language
 
-The following commands will help you find out which language is the
+The following commands help you find out which language is the
 working language, and also what language source files were written in.
 
 @kindex show language
@@ -5076,9 +5104,9 @@ build and compute expressions that may involve variables in your program.
 
 @item info frame
 Among the other information listed here (@pxref{Frame Info, ,Information
-about a frame}) is the source language for this frame.  This is the
-language that will become the working language if you ever use an
-identifier that is in this frame.
+about a frame}) is the source language for this frame.  This
+language becomes the working language if you use an
+identifier from this frame.
 
 @item info source
 Among the other information listed here (@pxref{Symbols, ,Examining the
@@ -5105,7 +5133,7 @@ by eliminating type mismatches, and providing active checks for range
 errors when your program is running.
 
 @value{GDBN} can check for conditions like the above if you wish.
-Although @value{GDBN} will not check the statements in your program, it
+Although @value{GDBN} does not check the statements in your program, it
 can check expressions entered directly into @value{GDBN} for evaluation via
 the @code{print} command, for example.  As with the working language,
 @value{GDBN} can also decide whether or not to check automatically based on
@@ -5267,7 +5295,7 @@ language.
 The following sections detail to what degree each source language is
 supported by @value{GDBN}.  These sections are not meant to be language
 tutorials or references, but serve only as a reference guide to what the
-@value{GDBN} expression parser will accept, and what input and output
+@value{GDBN} expression parser accepts, and what input and output
 formats should look like for different languages.  There are many good
 books written on each of these languages; please look to these for a
 language reference or tutorial.
@@ -5580,18 +5608,20 @@ interpret a significant subset of C++ expressions.
 @cindex @sc{xcoff} and C++
 @cindex @sc{elf}/stabs and C++
 @cindex @sc{elf}/@sc{dwarf} and C++
+@c FIXME!! GDB may eventually be able to debug C++ using DWARF; check
+@c periodically whether this has happened...
 @quotation
-@emph{Warning:} Most of these extensions depend on the use of additional
-debugging information in the symbol table, and thus require a rich,
-extendable object code format.  In particular, if your system uses
-a.out, MIPS @sc{ecoff}, RS/6000 @sc{xcoff}, or Sun @sc{elf} with stabs
-extensions to the symbol table, these facilities are all available.
-Where the object code format is standard @sc{coff}, on the other hand,
-most of the C++ support in @value{GDBN} will @emph{not} work, nor can it.
-For the standard SVr4 debugging format, @sc{dwarf} in @sc{elf}, the
-standard is still evolving, so the C++ support in @value{GDBN} is still
-fragile; when this debugging format stabilizes, however, C++ support
-will also be available on systems that use it.
+@emph{Warning:} @value{GDBN} can only debug C++ code if you compile with
+the GNU C++ compiler.  Moreover, C++ debugging depends on the use of
+additional debugging information in the symbol table, and thus requires
+special support.  @value{GDBN} has this support @emph{only} with the
+stabs debug format.  In particular, if your compiler generates a.out,
+MIPS @sc{ecoff}, RS/6000 @sc{xcoff}, or @sc{elf} with stabs extensions
+to the symbol table, these facilities are all available.  (With GNU CC,
+you can use the @samp{-gstabs} option to request stabs debugging
+extensions explicitly.)  Where the object code format is standard
+@sc{coff} or @sc{dwarf} in @sc{elf}, on the other hand, most of the C++
+support in @value{GDBN} does @emph{not} work.
 @end quotation
 
 @enumerate
@@ -5615,10 +5645,10 @@ pointer @code{this} following the same rules as C++.
 @cindex call overloaded functions
 @cindex type conversions in C++
 @item
-You can call overloaded functions; @value{GDBN} will resolve the function
+You can call overloaded functions; @value{GDBN} resolves the function
 call to the right definition, with one restriction---you must use
 arguments of the type required by the function that you want to call.
-@value{GDBN} will not perform conversions requiring constructors or
+@value{GDBN} does not perform conversions requiring constructors or
 user-defined type operators.
 
 @cindex reference declarations
@@ -5667,8 +5697,8 @@ further details.
 @cindex C and C++ checks
 
 By default, when @value{GDBN} parses C or C++ expressions, type checking
-is not used.  However, if you turn type checking on, @value{GDBN} will
-consider two variables type equivalent if:
+is not used.  However, if you turn type checking on, @value{GDBN}
+considers two variables type equivalent if:
 
 @itemize @bullet
 @item
@@ -5710,8 +5740,8 @@ inside a @code{struct}
 @ifclear CONLY
 or @code{class}
 @end ifclear
-will also be printed.
-Otherwise, it will appear as @samp{@{...@}}.
+is also printed.
+Otherwise, it appears as @samp{@{...@}}.
 
 The @code{@@} operator aids in the debugging of dynamic arrays, formed
 with pointers and a memory allocation function.  @xref{Expressions,
@@ -5791,8 +5821,8 @@ available choices, or to finish the type list for you.
 The extensions made to @value{GDBN} to support Modula-2 only support
 output from the GNU Modula-2 compiler (which is currently being
 developed).  Other Modula-2 compilers are not currently supported, and
-attempting to debug executables produced by them will most likely
-result in an error as @value{GDBN} reads in the executable's symbol
+attempting to debug executables produced by them is most likely
+to give an error as @value{GDBN} reads in the executable's symbol
 table.
 
 @cindex expressions in Modula-2
@@ -5925,7 +5955,7 @@ as @code{^}.
 
 @quotation
 @emph{Warning:} Sets and their operations are not yet supported, so @value{GDBN}
-will treat the use of the operator @code{IN}, or the use of operators
+treats the use of the operator @code{IN}, or the use of operators
 @code{+}, @code{-}, @code{*}, @code{/}, @code{=}, , @code{<>}, @code{#},
 @code{<=}, and @code{>=} on sets as an error.
 @end quotation
@@ -6038,7 +6068,7 @@ Returns the member of the type @var{t} whose ordinal value is @var{i}.
 
 @quotation
 @emph{Warning:}  Sets and their operations are not yet supported, so
-@value{GDBN} will treat the use of procedures @code{INCL} and @code{EXCL} as
+@value{GDBN} treats the use of procedures @code{INCL} and @code{EXCL} as
 an error.
 @end quotation
 
@@ -6102,7 +6132,7 @@ Modula-2.  This happens regardless of whether you, or @value{GDBN},
 selected the working language.
 
 If you allow @value{GDBN} to set the language automatically, then entering
-code compiled from a file whose name ends with @file{.mod} will set the
+code compiled from a file whose name ends with @file{.mod} sets the
 working language to Modula-2. @xref{Automatically, ,Having @value{GDBN} set
 the language automatically}, for further details.
 
@@ -6124,7 +6154,7 @@ returned a pointer.)
 
 @item
 C escape sequences can be used in strings and characters to represent
-non-printable characters.  @value{GDBN} will print out strings with these
+non-printable characters.  @value{GDBN} prints out strings with these
 escape sequences embedded.  Single non-printable characters are
 printed using the @samp{CHR(@var{nnn})} format.
 
@@ -6194,7 +6224,7 @@ identifier within your program, except another module.
 
 Using the @code{::} operator makes @value{GDBN} search the scope
 specified by @var{scope} for the identifier @var{id}.  If it is not
-found in the specified scope, then @value{GDBN} will search all scopes
+found in the specified scope, then @value{GDBN} searches all scopes
 enclosing the one specified by @var{scope}.
 
 Using the @code{.} operator makes @value{GDBN} search the current scope for
@@ -6522,7 +6552,7 @@ an address of your own choosing, with the following commands:
 @table @code
 @item jump @var{linespec}
 @kindex jump
-Resume execution at line @var{linespec}.  Execution will stop
+Resume execution at line @var{linespec}.  Execution stops again
 immediately if there is a breakpoint there.  @xref{List, ,Printing
 source lines}, for a description of the different forms of
 @var{linespec}.
@@ -6544,14 +6574,14 @@ Resume execution at the instruction at address @var{address}.
 You can get much the same effect as the @code{jump} command by storing a
 new value into the register @code{$pc}.  The difference is that this
 does not start your program running; it only changes the address where it
-@emph{will} run when it is continued.  For example,
+@emph{will} run when you continue.  For example,
 
 @example
 set $pc = 0x485
 @end example
 
 @noindent
-causes the next @code{continue} command or stepping command to execute at
+makes the next @code{continue} command or stepping command execute at
 address @code{0x485}, rather than at the address where your program stopped.
 @xref{Continuing and Stepping, ,Continuing and stepping}.
 
@@ -6664,12 +6694,12 @@ repairs.
 @item set write on
 @itemx set write off
 @kindex set write
-If you specify @samp{set write on}, @value{GDBN} will open executable 
+If you specify @samp{set write on}, @value{GDBN} opens executable 
 @ifclear BARETARGET
 and core
 @end ifclear
 files for both reading and writing; if you specify @samp{set write
-off} (the default), @value{GDBN} will open them read-only.
+off} (the default), @value{GDBN} opens them read-only.
 
 If you have already loaded a file, you must load it again (using the
 @code{exec-file}
@@ -6685,7 +6715,7 @@ Display whether executable files
 @ifclear BARETARGET
 and core files 
 @end ifclear
-will be opened for writing as well as reading.
+are opened for writing as well as reading.
 @end table
 
 @node GDB Files
@@ -6737,13 +6767,13 @@ search, just as the shell does when looking for a program to run.  You
 can change the value of this variable, for both @value{GDBN} and your program,
 using the @code{path} command.
 
-On systems with memory-mapped files, an auxiliary symbol table file
-@file{@var{filename}.syms} may be available for @var{filename}.  If it
-is, @value{GDBN} will map in the symbol table from
+On systems with memory-mapped files, an auxiliary file
+@file{@var{filename}.syms} may hold symbol table information for
+@var{filename}.  If so, @value{GDBN} maps in the symbol table from
 @file{@var{filename}.syms}, starting up more quickly.  See the
-descriptions of the options @samp{-mapped} and @samp{-readnow} (available
-on the command line, and with the commands @code{file}, @code{symbol-file},
-or @code{add-symbol-file}), for more information.
+descriptions of the options @samp{-mapped} and @samp{-readnow}
+(available on the command line, and with the commands @code{file},
+@code{symbol-file}, or @code{add-symbol-file}), for more information.
 
 @item file
 @code{file} with no argument makes @value{GDBN} discard any information it
@@ -6752,7 +6782,7 @@ has on both executable file and the symbol table.
 @item exec-file @r{[} @var{filename} @r{]}
 @kindex exec-file
 Specify that the program to be run (but not the symbol table) is found
-in @var{filename}.  @value{GDBN} will search the environment variable @code{PATH}
+in @var{filename}.  @value{GDBN} searches the environment variable @code{PATH}
 if necessary to locate your program.  Omitting @var{filename} means to
 discard information on the executable file.
 
@@ -6771,11 +6801,11 @@ auto-display expressions.  This is because they may contain pointers to
 the internal data recording symbols and data types, which are part of
 the old symbol table data being discarded inside @value{GDBN}.
 
-@code{symbol-file} will not repeat if you press @key{RET} again after
+@code{symbol-file} does not repeat if you press @key{RET} again after
 executing it once.
 
-When @value{GDBN} is configured for a particular environment, it will
-understand debugging information in whatever format is the standard
+When @value{GDBN} is configured for a particular environment, it
+understands debugging information in whatever format is the standard
 generated for that environment; you may use either a GNU compiler, or
 other compilers that adhere to the local conventions.  Best results are
 usually obtained from GNU compilers; for example, using @code{@value{GCC}}
@@ -6815,7 +6845,7 @@ entire symbol table available.
 If memory-mapped files are available on your system through the
 @code{mmap} system call, you can use another option, @samp{-mapped}, to
 cause @value{GDBN} to write the symbols for your program into a reusable
-file.  Future @value{GDBN} debugging sessions will map in symbol information
+file.  Future @value{GDBN} debugging sessions map in symbol information
 from this auxiliary symbol file (if the program has not changed), rather
 than spending time reading the symbol table from the executable
 program.  Using the @samp{-mapped} option has the same effect as
@@ -6826,7 +6856,7 @@ file has all the symbol information for your program.
 
 The auxiliary symbol file for a program called @var{myprog} is called
 @samp{@var{myprog}.syms}.  Once this file exists (so long as it is newer
-than the corresponding executable), @value{GDBN} will always attempt to use
+than the corresponding executable), @value{GDBN} always attempts to use
 it when you debug @var{myprog}; no special options or commands are
 needed.
 
@@ -6882,14 +6912,14 @@ specifies a fixed address.
 @c FIXME! This would be a good place for an xref to the GNU linker doc.
 
 @ifset VXWORKS
-On VxWorks, @code{load} will dynamically link @var{filename} on the
+On VxWorks, @code{load} links @var{filename} dynamically on the
 current target system as well as adding its symbols in @value{GDBN}.
 @end ifset
 
 @ifset I960
 @cindex download to Nindy-960
-With the Nindy interface to an Intel 960 board, @code{load} will
-download @var{filename} to the 960 as well as adding its symbols in
+With the Nindy interface to an Intel 960 board, @code{load}
+downloads @var{filename} to the 960 as well as adding its symbols in
 @value{GDBN}.
 @end ifset
 
@@ -6905,7 +6935,7 @@ opens it as the current executable target for @value{GDBN} on your host
 (like the @code{file} command).
 @end ifset
 
-@code{load} will not repeat if you press @key{RET} again after using it.
+@code{load} does not repeat if you press @key{RET} again after using it.
 
 @ifclear BARETARGET
 @item add-symbol-file @var{filename} @var{address}
@@ -6925,7 +6955,7 @@ originally read with the @code{symbol-file} command.  You can use the
 read keeps adding to the old.  To discard all old symbol data instead,
 use the @code{symbol-file} command.
 
-@code{add-symbol-file} will not repeat if you press @key{RET} after using it.
+@code{add-symbol-file} does not repeat if you press @key{RET} after using it.
 
 You can use the @samp{-mapped} and @samp{-readnow} options just as with
 the @code{symbol-file} command, to change how @value{GDBN} manages the symbol
@@ -6956,14 +6986,15 @@ name and remembers it that way.
 
 @ifclear BARETARGET
 @cindex shared libraries
-@value{GDBN} supports SunOS, SVR4, and IBM RS/6000 shared libraries.
+@value{GDBN} supports SunOS, SVr4, Irix 5, and IBM RS/6000 shared libraries.
 @value{GDBN} automatically loads symbol definitions from shared libraries
 when you use the @code{run} command, or when you examine a core file.
-(Before you issue the @code{run} command, @value{GDBN} will not understand
+(Before you issue the @code{run} command, @value{GDBN} does not understand
 references to a function in a shared library, however---unless you are
 debugging a core file).
-@c FIXME: next @value{GDBN} release should permit some refs to undef
-@c FIXME...symbols---eg in a break cmd---assuming they are from a shared lib
+@c FIXME: some @value{GDBN} release may permit some refs to undef
+@c FIXME...symbols---eg in a break cmd---assuming they are from a shared
+@c FIXME...lib; check this from time to time when updating manual
 
 @table @code
 @item info share
@@ -6978,7 +7009,7 @@ Print the names of the shared libraries which are currently loaded.
 @kindex share
 This is an obsolescent command; you can use it to explicitly load shared
 object library symbols for files matching a Unix regular expression, but
-as with files loaded automatically, it will only load shared libraries
+as with files loaded automatically, it only loads shared libraries
 required by your program for a core file or after typing @code{run}.  If
 @var{regex} is omitted all shared libraries required by your program are
 loaded.
@@ -6988,7 +7019,7 @@ loaded.
 @node Symbol Errors
 @section Errors reading symbol files
 
-While reading a symbol file, @value{GDBN} will occasionally encounter problems,
+While reading a symbol file, @value{GDBN} occasionally encounters problems,
 such as symbol types it does not recognize, or known bugs in compiler
 output.  By default, @value{GDBN} does not notify you of such problems, since
 they are relatively common and primarily of interest to people
@@ -7021,7 +7052,7 @@ The symbol information for symbol scope blocks should occur in
 order of increasing addresses.  This error indicates that it does not
 do so.
 
-@value{GDBN} does not circumvent this problem, and will have trouble
+@value{GDBN} does not circumvent this problem, and has trouble
 locating symbols in the source file whose symbols it is reading.  (You
 can often determine what source file is affected by specifying
 @code{set verbose on}.  @xref{Messages/Warnings, ,Optional warnings and
@@ -7053,8 +7084,8 @@ know how to read.  @code{0x@var{nn}} is the symbol type of the misunderstood
 information, in hexadecimal.
 
 @value{GDBN} circumvents the error by ignoring this symbol information.  This
-will usually allow your program to be debugged, though certain symbols
-will not be accessible.  If you encounter such a problem and feel like
+usually allows you to debug your program, though certain symbols
+are not accessible.  If you encounter such a problem and feel like
 debugging it, you can debug @code{@value{GDBP}} with itself, breakpoint on
 @code{complain}, then go up to the function @code{read_dbx_symtab} and
 examine @code{*bufp} to see the symbol.
@@ -7124,7 +7155,7 @@ file.
 For example, if you execute @samp{gdb a.out}, then the executable file
 @code{a.out} is the only active target.  If you designate a core file as
 well---presumably from a prior run that crashed and coredumped---then
-@value{GDBN} has two active targets and will use them in tandem, looking
+@value{GDBN} has two active targets and uses them in tandem, looking
 first in the corefile target, then in the executable file, to satisfy
 requests for memory addresses.  (Typically, these two classes of target
 are complementary, since core files contain only a program's
@@ -7173,7 +7204,7 @@ typically include things like device names or host names to connect
 with, process numbers, and baud rates.
 @end ifclear
 
-The @code{target} command will not repeat if you press @key{RET} again
+The @code{target} command does not repeat if you press @key{RET} again
 after executing the command.
 
 @item help target
@@ -7292,7 +7323,7 @@ Some configurations of GDB have special serial or TCP/IP interfaces
 to make this work with particular debugging targets.  In addition,
 GDB comes with a generic serial protocol (specific to GDB, but
 not specific to any particular target system) which you can use if you
-write the remote stubs---the code that will run on the remote system to
+write the remote stubs---the code that runs on the remote system to
 communicate with GDB.
 
 Other remote targets may be available in your
@@ -7411,13 +7442,14 @@ history facility.
 @cindex history substitution
 @cindex history file
 @kindex set history filename
+@kindex GDBHISTFILE
 @item set history filename @var{fname}
-Set the name of the @value{GDBN} command history file to @var{fname}.  This is
-the file from which @value{GDBN} will read an initial command history
-list or to which it will write this list when it exits.  This list is
-accessed through history expansion or through the history
-command editing characters listed below.  This file defaults to the
-value of the environment variable @code{GDBHISTFILE}, or to
+Set the name of the @value{GDBN} command history file to @var{fname}.
+This is the file where @value{GDBN} reads an initial command history
+list, and where it writes the command history from this session when it
+exits.  You can access this list through history expansion or through
+the history command editing characters listed below.  This file defaults
+to the value of the environment variable @code{GDBHISTFILE}, or to
 @file{./.gdb_history} if this variable is not set.
 
 @cindex history save
@@ -7433,7 +7465,7 @@ Stop recording command history in a file.
 @cindex history size
 @kindex set history size
 @item set history size @var{size}
-Set the number of commands which @value{GDBN} will keep in its history list.
+Set the number of commands which @value{GDBN} keeps in its history list.
 This defaults to the value of the environment variable
 @code{HISTSIZE}, or to 256 if this variable is not set.
 @end table
@@ -7449,7 +7481,7 @@ is off by default. If you decide to enable history expansion with the
 @code{set history expansion on} command, you may sometimes need to
 follow @kbd{!} (when it is used as logical not, in an expression) with
 a space or a tab to prevent it from being expanded.  The readline
-history facilities will not attempt substitution on the strings
+history facilities do not attempt substitution on the strings
 @kbd{!=} and @kbd{!(}, even when history expansion is enabled.
 
 The commands to control history expansion are:
@@ -7528,7 +7560,7 @@ These @code{set} commands specify a screen height of @var{lpp} lines and
 a screen width of @var{cpl} characters.  The associated @code{show}
 commands display the current settings.
 
-If you specify a height of zero lines, @value{GDBN} will not pause during output
+If you specify a height of zero lines, @value{GDBN} does not pause during output
 no matter how long the output is.  This is useful if output is to a file
 or to an editor buffer.
 
@@ -7564,8 +7596,8 @@ set radix 0xa
 @end example
 
 @noindent
-will set the base to decimal.  On the other hand, @samp{set radix 10}
-will leave the radix unchanged no matter what it was.
+sets the base to decimal.  On the other hand, @samp{set radix 10}
+leaves the radix unchanged no matter what it was.
 
 @kindex show radix
 @item show radix
@@ -7577,7 +7609,7 @@ Display the current default base for numeric input and display.
 
 By default, @value{GDBN} is silent about its inner workings.  If you are running
 on a slow machine, you may want to use the @code{set verbose} command.
-It will make @value{GDBN} tell you when it does a lengthy internal operation, so
+It makes @value{GDBN} tell you when it does a lengthy internal operation, so
 you will not think it has crashed.
 
 Currently, the messages controlled by @code{set verbose} are those
@@ -7710,7 +7742,7 @@ Give documentation to the user-defined command @var{commandname}.  The
 command @var{commandname} must already be defined.  This command reads
 lines of documentation just as @code{define} reads the lines of the
 command definition, ending with @code{end}.  After the @code{document}
-command is finished, @code{help} on command @var{commandname} will print
+command is finished, @code{help} on command @var{commandname} displays
 the documentation you have specified.
 
 You may use the @code{document} command again to change the
@@ -7783,7 +7815,7 @@ If an error occurs during the execution of your hook, execution of
 (before the command that you actually typed had a chance to run).
 
 If you try to define a hook which does not match any known command, you
-will get a warning from the @code{define} command.
+get a warning from the @code{define} command.
 
 @node Command Files
 @section Command files
@@ -7863,7 +7895,7 @@ want.
 @c because it is not in ANSI.
 Print @var{text}.  Nonprinting characters can be included in
 @var{text} using C escape sequences, such as @samp{\n} to print a
-newline.  @strong{No newline will be printed unless you specify one.}
+newline.  @strong{No newline is printed unless you specify one.}
 In addition to the standard C escape sequences, a backslash followed
 by a space stands for a space.  This is useful for displaying a
 string with spaces at the beginning or the end, since leading and
@@ -7969,15 +8001,15 @@ source display, and splits the screen to show both your @value{GDBN} session
 and the source.
 
 Explicit @value{GDBN} @code{list} or search commands still produce output as
-usual, but you probably will have no reason to use them.
+usual, but you probably have no reason to use them from Emacs.
 
 @quotation
 @emph{Warning:} If the directory where your program resides is not your
 current directory, it can be easy to confuse Emacs about the location of
-the source files, in which case the auxiliary display buffer will not
+the source files, in which case the auxiliary display buffer does not
 appear to show your source.  @value{GDBN} can find programs by searching your
 environment's @code{PATH} variable, so the @value{GDBN} input and output
-session will proceed normally; but Emacs does not get enough information
+session proceeds normally; but Emacs does not get enough information
 back from @value{GDBN} to locate the source files in this situation.  To
 avoid this problem, either start @value{GDBN} mode from the directory where
 your program resides, or specify a full path name when prompted for the
@@ -7999,7 +8031,7 @@ Emacs variable @code{gdb-command-name}; for example,
 
 @noindent
 (preceded by @kbd{ESC ESC}, or typed in the @code{*scratch*} buffer, or
-in your @file{.emacs} file) will make Emacs call the program named
+in your @file{.emacs} file) makes Emacs call the program named
 ``@code{mygdb}'' instead.
 
 In the @value{GDBN} I/O buffer, you can use these special Emacs commands in
@@ -8059,8 +8091,8 @@ argument for @code{disassemble} by typing @kbd{C-x &}.
 You can customize this further by defining elements of the list
 @code{gdb-print-command}; once it is defined, you can format or
 otherwise process numbers picked up by @kbd{C-x &} before they are
-inserted.  A numeric argument to @kbd{C-x &} will both indicate that you
-wish special formatting, and act as an index to pick an element of the
+inserted.  A numeric argument to @kbd{C-x &} indicates that you
+wish special formatting, and also acts as an index to pick an element of the
 list.  If the list element is a string, the number to be inserted is
 formatted using the Emacs function @code{format}; otherwise the number
 is passed as an argument to the corresponding list element.
@@ -8071,7 +8103,7 @@ tells @value{GDBN} to set a breakpoint on the source line point is on.
 
 If you accidentally delete the source-display buffer, an easy way to get
 it back is to type the command @code{f} in the @value{GDBN} buffer, to
-request a frame display; when you run under Emacs, this will recreate
+request a frame display; when you run under Emacs, this recreates
 the source buffer if necessary to show you the context of the current
 frame.
 
@@ -8079,7 +8111,7 @@ The source files displayed in Emacs are in ordinary Emacs buffers
 which are visiting the source files in the usual way.  You can edit
 the files with these buffers if you wish; but keep in mind that @value{GDBN}
 communicates with Emacs in terms of line numbers.  If you add or
-delete lines from the text, the line numbers that @value{GDBN} knows will cease
+delete lines from the text, the line numbers that @value{GDBN} knows cease
 to correspond properly with the code.
 
 @c The following dropped because Epoch is nonstandard.  Reactivate
@@ -8698,7 +8730,7 @@ with the @samp{--srcdir} option to specify where to find the source.
 (You also need to specify a path to find @code{configure}
 itself from your working directory.  If the path to @code{configure}
 would be the same as the argument to @samp{--srcdir}, you can leave out
-the @samp{--srcdir} option; it will be assumed.)
+the @samp{--srcdir} option; it is assumed.)
 
 For example, with version @value{GDBVN}, you can build GDB in a separate
 directory for a Sun 4 like this:
@@ -8824,7 +8856,7 @@ GDB source directories.  Among other things, you can use this to
 build (or maintain) several configurations simultaneously, in separate
 directories.  @code{configure} writes configuration specific files in
 the current directory, but arranges for them to use the source in the
-directory @var{path}.  @code{configure} will create directories under
+directory @var{path}.  @code{configure} creates directories under
 the working directory in parallel to the source directories below
 @var{path}.
 
diff --git a/gdb/doc/remote.texi b/gdb/doc/remote.texi
index cfa37ccbc0e..d21ecb12556 100644
--- a/gdb/doc/remote.texi
+++ b/gdb/doc/remote.texi
@@ -131,12 +131,12 @@ Use this auxiliary subroutine to make your program contain a
 breakpoint.  Depending on the particular situation, this may be the only
 way for @value{GDBN} to get control.  For instance, if your target
 machine has some sort of interrupt button, you won't need to call this;
-pressing the interrupt button will transfer control to
+pressing the interrupt button transfers control to
 @code{handle_exception}---in effect, to @value{GDBN}.  On some machines,
 simply receiving characters on the serial port may also trigger a trap;
 again, in that situation, you don't need to call @code{breakpoint} from
 your own program---simply running @samp{target remote} from the host
-@value{GDBN} session will get control.  
+@value{GDBN} session gets control.  
 
 Call @code{breakpoint} if none of these is true, or if you simply want
 to make certain your program stops at a predetermined point for the
@@ -229,7 +229,7 @@ either obtain it from your hardware manufacturer, or write your own.
 @end table
 
 If you do not use the GNU C compiler, you may need other standard
-library subroutines as well; this will vary from one stub to another,
+library subroutines as well; this varies from one stub to another,
 but in general the stubs are likely to use any of the common library
 subroutines which @code{gcc} generates as inline code.
 
@@ -430,7 +430,7 @@ If you have trouble with the serial connection, you can use the command
 back and forth across the serial line to the remote machine.  The
 packet-debugging information is printed on the @value{GDBN} standard output
 stream.  @code{set remotedebug off} turns it off, and @code{show
-remotedebug} will show you its current state.
+remotedebug} shows you its current state.
 
 @ifset GDBSERVER
 @node Server
@@ -788,7 +788,7 @@ Byte Write Available  = Yes
 @end example
 
 Then exit the @code{cu} or @code{tip} program (done in the example by
-typing @code{~.} at the @code{EBMON} prompt).  @code{EBMON} will keep
+typing @code{~.} at the @code{EBMON} prompt).  @code{EBMON} keeps
 running, ready for @value{GDBN} to take over.
 
 For this example, we've assumed what is probably the most convenient
@@ -797,7 +797,7 @@ system: a PC/NFS connection that establishes ``drive @code{G:}'' on the
 PC as a file system on the Unix host.  If you do not have PC/NFS or
 something similar connecting the two systems, you must arrange some
 other way---perhaps floppy-disk transfer---of getting the 29K program
-from the Unix system to the PC; @value{GDBN} will @emph{not} download it over the
+from the Unix system to the PC; @value{GDBN} does @emph{not} download it over the
 serial line.
 
 @node gdb-EB29K
@@ -878,7 +878,7 @@ concentrator) using the syntax @code{@var{hostname}:@var{portnumber}}.
 
 The @code{load} and @code{attach} commands are @emph{not} defined for
 this target; you must load your program into the ST2000 as you normally
-would for standalone operation.  @value{GDBN} will read debugging information
+would for standalone operation.  @value{GDBN} reads debugging information
 (such as symbols) from a separate, debugging version of the program
 available on your host computer.
 @c FIXME!! This is terribly vague; what little content is here is
@@ -900,7 +900,7 @@ manual for available commands.
 @cindex connect (to STDBUG)
 Connect the controlling terminal to the STDBUG command monitor.  When
 you are done interacting with STDBUG, typing either of two character
-sequences will get you back to the @value{GDBN} command prompt:
+sequences gets you back to the @value{GDBN} command prompt:
 @kbd{@key{RET}~.} (Return, followed by tilde and period) or
 @kbd{@key{RET}~@key{C-d}} (Return, followed by tilde and control-D).
 @end table
@@ -928,7 +928,7 @@ To use @value{GDBN} with VxWorks, you must rebuild your VxWorks kernel
 to include the remote debugging interface routines in the VxWorks
 library @file{rdb.a}.  To do this, define @code{INCLUDE_RDB} in the
 VxWorks configuration file @file{configAll.h} and rebuild your VxWorks
-kernel.  The resulting kernel will contain @file{rdb.a} and spawn the
+kernel.  The resulting kernel contains @file{rdb.a}, and spawns the
 source debugging task @code{tRdbTask} when VxWorks is booted.  For more
 information on configuring and remaking VxWorks, see the manufacturer's
 manual.
@@ -1023,7 +1023,7 @@ Reading symbol data from wherever/vw/demo/rdb/prog.o... done.
 
 You can also use the @code{load} command to reload an object module
 after editing and recompiling the corresponding source file.  Note that
-this will cause @value{GDBN} to delete all currently-defined breakpoints,
+this makes @value{GDBN} delete all currently-defined breakpoints,
 auto-displays, and convenience variables, and to clear the value
 history.  (This is necessary in order to preserve the integrity of
 debugger data structures that reference the target system's symbol
@@ -1042,7 +1042,7 @@ follows:
 
 @noindent
 where @var{task} is the VxWorks hexadecimal task ID.  The task can be running
-or suspended when you attach to it.  If running, it will be suspended at
+or suspended when you attach to it.  Running tasks are suspended at
 the time of attachment.
 @end ifset
 
@@ -1179,7 +1179,7 @@ normally.  The communications protocol provides no other way for @value{GDBN}
 to detect program completion.
 @end itemize
 
-In either case, @value{GDBN} will see the effect of a @sc{reset} on the
+In either case, @value{GDBN} sees the effect of a @sc{reset} on the
 development board as a ``normal exit'' of your program.
 @end ifset
 @end ifset
@@ -1357,6 +1357,6 @@ Execution time in 60ths of a second.
 
 You can refer to these values in @value{GDBN} expressions with the usual
 conventions; for example, @w{@samp{b fputc if $cycles>5000}} sets a
-conditional breakpoint that will suspend only after at least 5000
+conditional breakpoint that suspends only after at least 5000
 simulated clock ticks.
 @end ifset