*** empty log message ***

1 files changed, 29 insertions, 6287 deletions

diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index f9261e3..48ecdca 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -1,6 +1,9 @@
+_dnl__						-*-Texinfo-*-
+_dnl__ Copyright (c) 1988 1989 1990 1991 Free Software Foundation, Inc.
+_dnl__ This file controls overall layout of the GDB manual.
+_dnl__ $Id$
 \input texinfo
 @setfilename _GDBP__.info
-@c $Id$
 @c THIS MANUAL REQUIRES TEXINFO-2 macros and info-makers to format properly.
 @c
 @c NOTE: this manual is marked up for preprocessing with a collection
@@ -11,6298 +14,37 @@
 @c with all configurations, from wherever you got this).
 _if__(0)
 
-THIS IS THE FULL SOURCE.  The full source needs to be run through m4
-before either tex- or info- formatting: for example,
+THIS IS THE SOURCE PRIOR TO PREPROCESSING.  The full source needs to
+be run through m4 before either tex- or info- formatting: for example,
 _0__
-    m4 pretex.m4 none.m4 m680x0.m4 gdb.texinfo >gdb-680x0.texinfo
+    m4 pretex.m4 none.m4 m680x0.m4 gdb.texi-m4 >gdb-680x0.texinfo
 _1__
 will produce (assuming your path finds either GNU or SysV m4; Berkeley
 won't do) a file suitable for formatting.  See the text in "pretex.m4"
 for a fuller explanation (and the macro definitions).
-    To permit maximum flexibility, the full source also does not contain
-any "info" markup that can be generated automatically; you should first
-preprocess it as above, then run it through C-u texinfo-master-menu,
-before actually info-formatting it.
-_fi__(0)
-@c
-@syncodeindex ky cp
-@c FOR UPDATES LEADING TO THIS DRAFT, GDB CHANGELOG CONSULTED BETWEEN:
-@c Sun May 19 05:36:59 1991  John Gilmore  (gnu at cygint.cygnus.com)
-@c Sat Dec 22 02:51:40 1990  John Gilmore  (gnu at cygint)
-@ifinfo
-This file documents the GNU debugger _GDBN__.
-
-Copyright (C) 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
-
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-@ignore
-Permission is granted to process this file through TeX and print the
-results, provided the printed document carries copying permission
-notice identical to this one except for the removal of this paragraph
-(this paragraph not being relevant to the printed manual).
-
-@end ignore
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that the
-section entitled ``GNU General Public License'' is included exactly as
-in the original, and provided that the entire resulting derived work is
-distributed under the terms of a permission notice identical to this
-one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions,
-except that the section entitled ``GNU General Public License'' may be
-included in a translation approved by the Free Software Foundation
-instead of in the original English.
-@end ifinfo
-@smallbook
-@setchapternewpage odd
-_if__(_GENERIC__)
-@settitle Using _GDBN__ (v4.0)
-_fi__(_GENERIC__)
-_if__(!_GENERIC__)
-@settitle Using _GDBN__ v4.0 (_HOST__)
-_fi__(!_GENERIC__)
-@iftex
-@c @finalout
-@end iftex
-@titlepage
-@title{Using _GDBN__}
-@subtitle{A Guide to the GNU Source-Level Debugger}
-_if__(!_GENERIC__)
-@subtitle{On _HOST__ Systems}
-_fi__(!_GENERIC__)
-@sp 1
-@c Maybe crank this up to "Fourth Edition" when released at FSF
-@c @subtitle Third Edition---_GDBN__ version 4.0
-@subtitle _GDBN__ version 4.0
-@subtitle May 1991
-@author{Richard M. Stallman@qquad @hfill Free Software Foundation}
-@author{Roland H. Pesch@qquad @hfill Cygnus Support}
-@page
-
-@tex
-\def\$#1${{#1}}  % Kluge: collect RCS revision info without $...$
-\xdef\manvers{\$Revision$}  % For use in headers, footers too
-{\parskip=0pt
-\hfill rms\@ai.mit.edu, pesch\@cygnus.com\par
-\hfill {\it Using _GDBN__}, \manvers\par
-\hfill \TeX{}info \texinfoversion\par
-}
-@end tex
-
-@vskip 0pt plus 1filll
-Copyright @copyright{} 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
-
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that the
-section entitled ``GNU General Public License'' is included exactly as
-in the original, and provided that the entire resulting derived work is
-distributed under the terms of a permission notice identical to this
-one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions,
-except that the section entitled ``GNU General Public License'' may be
-included in a translation approved by the Free Software Foundation
-instead of in the original English.
-@end titlepage
-@page
-
-@node Top, Summary, (dir), (dir)
-@ifinfo
-This file describes version 4.0 of GDB, the GNU symbolic debugger.
-@end ifinfo
-
-@menu
-* Summary::			Summary of _GDBN__
-* New Features::		New Features in _GDBN__ version 4.0
-* Sample Session::		A Sample _GDBN__ Session
-* Invocation::			Getting In and Out of _GDBN__
-* Commands::			
-* Running::			Running Programs Under _GDBN__
-* Stopping::			Stopping and Continuing
-* Stack::			Examining the Stack
-* Source::			Examining Source Files
-* Data::			Examining Data
-* Symbols::			Examining the Symbol Table
-* Altering::			Altering Execution
-* _GDBN__ Files::		
-* Targets::			Specifying a Debugging Target 
-* Controlling _GDBN__::		Controlling _GDBN__
-* Sequences::			Canned Sequences of Commands
-* Emacs::			Using _GDBN__ under GNU Emacs
-* _GDBN__ Bugs::		Reporting Bugs in _GDBN__
-* Renamed Commands::		
-* Installing _GDBN__::		Installing _GDBN__
-* Copying::			GNU GENERAL PUBLIC LICENSE
-* Index::			Index
-@end menu
-
-@node Summary, New Features, Top, Top
-@unnumbered Summary of _GDBN__
-
-The purpose of a debugger such as _GDBN__ is to allow you to see what is
-going on ``inside'' another program while it executes---or what another
-program was doing at the moment it crashed.  
-
-_GDBN__ can do four main kinds of things (plus other things in support of
-these) to help you catch bugs in the act:
-
-@itemize @bullet
-@item
-Start your program, specifying anything that might affect its behavior.
-
-@item
-Make your program stop on specified conditions.
-
-@item
-Examine what has happened, when your program has stopped.
-
-@item
-Change things in your program, so you can experiment with correcting the
-effects of one bug and go on to learn about another.
-@end itemize
-
-_GDBN__ can be used to debug programs written in C and C++.  Pascal support
-is being implemented, and Fortran support will be added when a GNU
-Fortran compiler is ready.
-
-@menu
-* Free Software::		Free Software
-* Contributors::		Contributors to GDB
-@end menu
-
-@node Free Software, Contributors, Summary, Summary
-@unnumberedsec Free Software
-_GDBN__ is @dfn{free software}, protected by the GNU General Public License (GPL).
-The GPL gives you the freedom to copy or adapt a licensed
-program---but every person getting a copy also gets with it the
-freedom to modify that copy (which means that they must get access to
-the source code), and the freedom to distribute further copies.
-Typical software companies use copyrights to limit your freedoms; the
-Free Software Foundation uses the GPL to preserve these freedoms.
-
-Fundamentally, the General Public License is a license which says that
-you have these freedoms and that you can't take these freedoms away
-from anyone else.
-
-@c FIXME: (passim) go through all xrefs, expanding to use text headings
-For full details, @pxref{Copying}.
-@node Contributors,  , Free Software, Summary
-@unnumberedsec Contributors to GDB
-
-Richard Stallman was the original author of GDB, as with many GNU
-programs.  Many others have contributed to its development.  This
-section attempts to credit major contributors.  One of the virtues of
-free software is that everyone is free to contribute to it; with
-regret, we cannot actually acknowledge everyone here.  The file
-@file{ChangeLog} in the GDB distribution approximates a blow-by-blow
-account.
-
-Changes much prior to version 2.0 are lost in the mists of time.
-
-@quotation
-@emph{Plea:} Additions to this section are particularly welcome.  If you
-or your friends (or enemies; let's be evenhanded) have been unfairly
-omitted from this list, we would like to add your names!
-@end quotation
-
-So that they may not regard their long labor as thankless, we
-particularly thank those who shepherded GDB through major releases:
-John Gilmore (release 4.0); Jim Kingdon (releases 3.9, 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 contributed significantly to the structure,
-stability, and capabilities of the entire debugger.
-
-Richard Stallman, assisted at various times by Pete TerMaat, Chris
-Hanson, and Richard Mlynarik, handled releases through 2.8.
-
-Michael Tiemann is the author of most of the GNU C++ support in GDB,
-with significant additional contributions from Per Bothner.  James
-Clark wrote the GNU C++ demangler.  Early work on C++ was by Peter
-TerMaat (who also did much general update work leading to release 3.0).
-
-GDB 4.0 uses the BFD subroutine library to examine multiple
-object-file formats; BFD was a joint project of V. Gumby
-Henkel-Wallace, Rich Pixley, Steve Chamberlain, and John Gilmore.
-
-David Johnson wrote the original COFF support; Pace Willison did
-the original support for encapsulated COFF.
-
-Adam de Boor and Bradley Davis contributed the ISI Optimum V support.
-Per Bothner, Noboyuki Hikichi, and Alessandro Forin contributed MIPS
-support.  Jean-Daniel Fekete contributed Sun 386i support.  Chris
-Hanson improved the HP9000 support.  Noboyuki Hikichi and Tomoyuki
-Hasei contributed Sony/News OS 3 support.  David Johnson contributed
-Encore Umax support.  Jyrki Kuoppala contributed Altos 3068 support.
-Keith Packard contributed NS32K support.  Doug Rabson contributed
-Acorn Risc Machine support.  Chris Smith contributed Convex support
-(and Fortran debugging).  Jonathan Stone contributed Pyramid support.
-Michael Tiemann contributed SPARC support.  Tim Tucker contributed
-support for the Gould NP1 and Gould Powernode.  Pace Willison
-contributed Intel 386 support.  Jay Vosburgh contributed Symmetry
-support.
-
-Rich Schaefer helped with support of SunOS shared libraries.
-
-Jay Fenlason and Roland McGrath ensured that GDB and GAS agree about
-several machine instruction sets.
-
-Patrick Duval, Ted Goldstein, Vikram Koka and Glenn Engel helped
-develop remote debugging.  Intel Corporation and Wind River Systems
-contributed remote debugging modules for their products.
-
-Brian Fox is the author of the readline libraries providing
-command-line editing and command history.
-
-@node New Features, Sample Session, Summary, Top
-@unnumbered New Features since _GDBN__ version 3.5
-
-@table @emph
-@item Targets
-Using the new command @code{target}, you can select at runtime whether
-you are debugging local files, local processes, standalone systems over
-a serial port, realtime systems over a TCP/IP connection, etc.
-Internally, _GDBN__ now uses a function vector to mediate access to
-different targets; if you need to add your own support for a remote
-protocol, this makes it much easier.
-
-@item Watchpoints
-_GDBN__ now sports watchpoints as well as breakpoints.  You can use a
-watchpoint to stop execution whenever the value of an expression
-changes, without having to predict a particular place in your program
-where this may happen.
-
-@item Object Code Formats
-_GDBN__ uses a new scheme called Binary File Descriptors (BFD) to permit
-it to switch dynamically, without reconfiguration or recompilation,
-between different object-file formats.  Formats currently supported are
-COFF, a.out, and the Intel 960 b.out; files may be read as .o's, archive
-libraries, or core dumps.  BFD is available as a subroutine library so
-that other programs may take advantage of it, and the other GNU binary
-utilities are being converted to use it.
-
-@item Configuration
-Compile-time configuration (to select a particular architecture and
-operating system) is much easier.  The script @code{config.gdb} now
-handles specification of separate host and target configurations.
-
-@item Interaction
-The user interface to _GDBN__'s control variables has been simplified
-and consolidated in two commands, @code{set} and @code{show}.  Output
-lines are now broken at readable places, rather than overflowing onto
-the next line.  You can suppress output of machine-level addresses,
-displaying only source language information.
-
-
-@item Source Language
-_GDBN__ now has limited support for C++ exception handling: _GDBN__ can
-break when an exception is raised, before the stack is peeled back to
-the exception handler's context.  
-
-@item Command Rationalization
-Many _GDBN__ commands have been renamed to make them easier to remember
-and use.  In particular, the subcommands of @code{info} and
-@code{show}/@code{set} are grouped to make the former refer to the state
-of your program, and the latter refer to the state of _GDBN__ itself.
-@xref{Renamed Commands}, for details on what commands were renamed.
-
-@item Ports
-_GDBN__ has been ported to the following new architectures: AT&T 3b1,
-Acorn RISC machine, HP300 running HPUX, big- and little-endian MIPS
-machines, Motorola 88k, Sun 386i, and Sun 3 running SunOS 4.  In
-addition, the following are supported as targets only: AMD 29k, Intel
-960, and Wind River's VxWorks.
-
-@item Shared Libraries
-_GDBN__ 4.0 supports SunOS shared libraries.
-
-@item Work in Progress
-Kernel debugging for BSD and Mach systems; Tahoe and HPPA architecture
-support.
-
-@end table
-
-@node Sample Session, Invocation, New Features, Top
-@chapter A Sample _GDBN__ Session
-
-You can use this manual at your leisure to read all about _GDBN__.
-However, a handful of commands are enough to get started using the
-debugger.  This chapter illustrates these commands.
-
-@iftex
-In this sample session, we emphasize user input like this: @i{input},
-to make it easier to pick out from the surrounding output.
-@end iftex
-
-@c FIXME: this example may not be appropriate for some configs, where
-@c FIXME...primary interest is in remote use.
-_0__
-One of the preliminary versions of GNU @code{m4} (a generic macro
-processor) exhibits the following bug: sometimes, when we change its
-quote strings from the default, the commands used to capture one macro's
-definition in another stop working.  In the following short @code{m4}
-session, we define a macro @code{foo} which expands to @code{0000}; we
-then use the @code{m4} builtin @code{defn} to define @code{bar} as the
-same thing.  However, when we change the open quote string to
-@code{<QUOTE>} and the close quote string to @code{<UNQUOTE>}, the same
-procedure fails to define a new synonym @code{baz}:
-
-@smallexample
-$ @i{cd gnu/m4}
-$ @i{./m4}
-@i{define(foo,0000)}
-
-@i{foo}
-0000
-@i{define(bar,defn(`foo'))}
-
-@i{bar}
-0000
-@i{changequote(<QUOTE>,<UNQUOTE>)}
-
-@i{define(baz,defn(<QUOTE>foo<UNQUOTE>))}
-@i{baz}
-@i{C-D}
-m4: End of input: 0: fatal error: EOF in string
-@end smallexample
-
-@noindent
-Let's use _GDBN__ to try to see what's going on.
-
-@smallexample
-$ @i{_GDBP__ m4}
-Reading symbol data from m4...done.
-(_GDBP__) 
-@end smallexample
-
-@noindent
-_GDBN__ only reads enough symbol data to know where to find the rest
-when needed; as a result, the first prompt comes up very quickly.  We
-then tell _GDBN__ to use a narrower display width than usual, so
-that examples will fit in this manual.
-
-@smallexample
-(_GDBP__) @i{set width 70}
-@end smallexample
-
-@noindent 
-Let's see how the @code{m4} builtin @code{changequote} works.
-Having looked at the source, we know the relevant subroutine is
-@code{m4_changequote}, so we set a breakpoint there with _GDBN__'s
-@code{break} command.
-
-@smallexample
-(_GDBP__) @i{break m4_changequote}
-Breakpoint 1 at 0x62f4: file builtin.c, line 879.
-@end smallexample
-
-@noindent
-Using the @code{run} command, we start @code{m4} running under _GDBN__
-control; as long as control does not reach the @code{m4_changequote}
-subroutine, the program runs as usual:
-
-@smallexample
-(_GDBP__) @i{run}
-Starting program: /work/Editorial/gdb/gnu/m4/m4 
-@i{define(foo,0000)}
-
-@i{foo}
-0000
-@end smallexample
-
-@noindent
-To trigger the breakpoint, we call @code{changequote}.  _GDBN__
-suspends execution of @code{m4}, displaying information about the
-context where it stops.
-
-@smallexample
-@i{changequote(<QUOTE>,<UNQUOTE>)}
-
-Breakpoint 1, m4_changequote (argc=3, argv=0x33c70) at builtin.c:879
-879         if (bad_argc(TOKEN_DATA_TEXT(argv[0]), argc, 1, 3))
-@end smallexample
-
-@noindent
-Now we use the command @code{n} (@code{next}) to advance execution to
-the next line of the current function.
-
-@smallexample
-(_GDBP__) @i{n}
-882         set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1]) : nil,
-@end smallexample
-
-@noindent
-@code{set_quotes} looks like a promising subroutine.  We can go into it
-by using the command @code{s} (@code{step}) instead of @code{next}.
-@code{step} goes to the next line to be executed in @emph{any}
-subroutine, so it steps into @code{set_quotes}.  
-
-@smallexample
-(_GDBP__) @i{s}
-set_quotes (lq=0x34c78 "<QUOTE>", rq=0x34c88 "<UNQUOTE>")
-    at input.c:530
-530         if (lquote != def_lquote)
-@end smallexample
-
-@noindent
-The summary display showing the subroutine where @code{m4} is now
-suspended (and its arguments) is called a stack frame display.  We can
-use the @code{backtrace} command (which can also be spelled @code{bt}),
-to see where we are in the stack: it displays a stack frame for each
-active subroutine.
-
-@smallexample
-(_GDBP__) @i{bt}
-#0  set_quotes (lq=0x34c78 "<QUOTE>", rq=0x34c88 "<UNQUOTE>")
-    at input.c:530
-#1  0x6344 in m4_changequote (argc=3, argv=0x33c70) at builtin.c:882
-#2  0x8174 in expand_macro (sym=0x33320) at macro.c:242
-#3  0x7a88 in expand_token (obs=0x0, t=209696, td=0xf7fffa30)
-    at macro.c:71
-#4  0x79dc in expand_input () at macro.c:40
-#5  0x2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195
-@end smallexample
-
-@noindent
-Let's 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.
-@smallexample
-(_GDBP__) @i{s}
-0x3b5c  532         if (rquote != def_rquote)
-(_GDBP__) @i{s}
-0x3b80  535         lquote = (lq == nil || *lq == '\0') ? def_lquote :\
- xstrdup(lq);
-(_GDBP__) @i{n}
-536         rquote = (rq == nil || *rq == '\0') ? def_rquote : xstrdup\
-(rq);
-(_GDBP__) @i{n}
-538         len_lquote = strlen(rquote);
-@end smallexample
-
-@noindent
-The last line displayed looks a little odd; let's examine the variables
-@code{lquote} and @code{rquote} to see if they are in fact the new left
-and right quotes we specified.  We can use the command @code{p}
-(@code{print}) to see their values.
-
-@smallexample
-(_GDBP__) @i{p lquote}
-$1 = 0x35d40 "<QUOTE>"
-(_GDBP__) @i{p rquote}
-$2 = 0x35d50 "<UNQUOTE>"
-@end smallexample
-
-@noindent
-@code{lquote} and @code{rquote} are indeed the new left and right quotes.
-Let's look at some context; we can display ten lines of source
-surrounding the current line, with the @code{l} (@code{list}) command.
-
-@smallexample
-(_GDBP__) @i{l}
-533             xfree(rquote);
-534     
-535         lquote = (lq == nil || *lq == '\0') ? def_lquote : xstrdup\
-(lq);
-536         rquote = (rq == nil || *rq == '\0') ? def_rquote : xstrdup\
-(rq);
-537     
-538         len_lquote = strlen(rquote);
-539         len_rquote = strlen(lquote);
-540     @}
-541     
-542     void
-@end smallexample
-
-@noindent
-Let's step past the two lines that set @code{len_lquote} and
-@code{len_rquote}, and then examine the values of those variables.
-
-@smallexample
-(_GDBP__) @i{n}
-539         len_rquote = strlen(lquote);
-(_GDBP__) @i{n}
-540     @}
-(_GDBP__) @i{p len_lquote}
-$3 = 9
-(_GDBP__) @i{p len_rquote}
-$4 = 7
-@end smallexample
-
-@noindent
-That certainly looks wrong, assuming @code{len_lquote} and
-@code{len_rquote} are meant to be the lengths of @code{lquote} and
-@code{rquote} respectively.  Let's try setting them to better values.
-We can use the @code{p} command for this, since it'll print the value of
-any expression---and that expression can include subroutine calls and
-assignments. 
-
-@smallexample
-(_GDBP__) p len_lquote=strlen(lquote)
-$5 = 7
-(_GDBP__) p len_rquote=strlen(rquote)
-$6 = 9
-@end smallexample
-
-@noindent
-Let's see if that fixes the problem of using the new quotes with the
-@code{m4} built-in @code{defn}.  We can allow @code{m4} to continue
-executing with the @code{c} (@code{continue}) command, and then try the
-example that caused trouble initially:
-
-@smallexample
-(_GDBP__) @i{c}
-Continuing.
-
-@i{define(baz,defn(<QUOTE>foo<UNQUOTE>))}
-
-baz
-0000
-@end smallexample
-
-@noindent
-Success!  The new quotes now work just as well as the default ones.  The
-problem seems to have been just the two typos defining the wrong
-lengths.  We'll let @code{m4} exit by giving it an EOF as input.
-
-@smallexample
-@i{C-D}
-Program exited normally.
-@end smallexample
-
-@noindent 
-The message @samp{Program exited normally.} is from _GDBN__; it
-indicates @code{m4} has finished executing.  We can end our _GDBN__
-session with the _GDBN__ @code{quit} command.
-
-@smallexample
-(_GDBP__) @i{quit}
-
-$ 
-_1__@end smallexample
-
-
-@node Invocation, Commands, Sample Session, Top
-@chapter Getting In and Out of _GDBN__
-
-@menu
-* Starting _GDBN__::		Starting _GDBN__
-* Leaving _GDBN__::		Leaving _GDBN__
-* Shell Commands::		Shell Commands
-@end menu
-
-@node Starting _GDBN__, Leaving _GDBN__, Invocation, Invocation
-@section Starting _GDBN__
-
-_GDBN__ is invoked with the shell command @code{_GDBP__}.  Once started,
-it reads commands from the terminal until you tell it to exit.
-
-You can run @code{_GDBP__} with no arguments or options; but the most
-usual way to start _GDBN__ is with one argument or two, specifying an
-executable program as the argument:
-@example
-_GDBP__ program
-@end example
-@noindent
-You can also start with both an executable program and a core file specified:
-@example
-_GDBP__ program core
-@end example
-
-@noindent
-You can further control how _GDBN__ starts up by using command-line
-options.  _GDBN__ itself can remind you of the options available:
-@example
-_GDBP__ -help
-@end example
-@noindent
-will display all available options and briefly describe their use
-(@samp{_GDBP__ -h} is a shorter equivalent).
-
-All options and command line arguments you give are processed
-in sequential order.  The order makes a difference when the
-@samp{-x} option is used.  
-
-@menu
-* File Options::		Choosing Files
-* Mode Options::		Choosing Modes
-_if__(_GENERIC__)
-_divert__(1)
-_fi__(_GENERIC__)
-* i960-Nindy Remote::		
-* EB29K Remote::		
-* VxWorks Remote::		
-_if__(_GENERIC__)
-_divert__
-_fi__(_GENERIC__)
-@end menu
-
-@node File Options, Mode Options, Starting _GDBN__, Starting _GDBN__
-@subsection Choosing Files
-
-As shown above, any arguments other than options specify an executable
-file and core file; that is, the first argument encountered with no
-associated option flag is equivalent to a @samp{-se} option, and the
-second, if any, is equivalent to a @samp{-c} option.  Many options have
-both long and short forms; both are shown here.  The long forms are also
-recognized if you truncate them, so long as enough of the option is
-present to be unambiguous.  (If you prefer, you can flag option
-arguments with @samp{+} rather than @samp{-}, though we illustrate the
-more usual convention.)
-
-@table @code
-@item -symbols=@var{file}
-@itemx -s @var{file}
-Read symbol table from file @var{file}.
-
-@item -exec=@var{file}
-@itemx -e @var{file}
-Use file @var{file} as the executable file to execute when
-appropriate, and for examining pure data in conjunction with a core
-dump.
-
-@item -se @var{file}
-Read symbol table from file @var{file} and use it as the executable
-file.
-
-@item -core=@var{file}
-@itemx -c @var{file}
-Use file @var{file} as a core dump to examine.
-
-@item -command=@var{file}
-@itemx -x @var{file}
-Execute _GDBN__ commands from file @var{file}.  @xref{Command Files}.
-
-@item -directory=@var{directory}
-@itemx -d @var{directory}
-Add @var{directory} to the path to search for source files.
-@end table
-
-@node Mode Options, i960-Nindy Remote, File Options, Starting _GDBN__
-@subsection Choosing Modes
-
-@table @code
-@item -nx
-@itemx -n
-Do not execute commands from any @file{_GDBINIT__} initialization files.
-Normally, the commands in these files are executed after all the
-command options and arguments have been processed.  @xref{Command
-Files}.
-
-@item -quiet
-@itemx -q
-``Quiet''.  Do not print the introductory and copyright messages.  These
-messages are also suppressed in batch mode, or if an executable file name is
-specified on the _GDBN__ command line.
-
-@item -batch
-Run in batch mode.  Exit with status @code{0} after processing all the command
-files specified with @samp{-x} (and @file{_GDBINIT__}, if not inhibited).
-Exit with nonzero status if an error occurs in executing the _GDBN__
-commands in the command files.  
-
-Batch mode may be useful for running _GDBN__ as a filter, for example to
-download and run a program on another computer; in order to make this
-more useful, the message 
-@example
-Program exited normally.
-@end example
-@noindent
-(which is ordinarily issued whenever a program running under _GDBN__ control
-terminates) is not issued when running in batch mode.
-
-@item -cd @var{directory}
-Run _GDBN__ using @var{directory} as its working directory,
-instead of the current directory.
-
-@item -fullname
-@itemx -f
-This option is used when Emacs runs _GDBN__ as a subprocess.  It tells _GDBN__
-to output the full file name and line number in a standard,
-recognizable fashion each time a stack frame is displayed (which
-includes each time the program stops).  This recognizable format looks
-like two @samp{\032} characters, followed by the file name, line number
-and character position separated by colons, and a newline.  The
-Emacs-to-_GDBN__ interface program uses the two @samp{\032} characters as
-a signal to display the source code for the frame.
-
-@item -b @var{bps}
-Set the line speed (baud rate or bits per second) of any serial
-interface used by _GDBN__ for remote debugging.
-
-@item -tty @var{device}
-Run using @var{device} for your program's standard input and output.
-@c FIXME: kingdon thinks there's more to -tty.  Investigate.
-@end table
-
-_if__(_GENERIC__)
-_divert__(2)
-@c This text diverted to "Remote Debugging" section in general case;
-@c however, if we're doing a manual specifically for one of these, it
-@c belongs up front (in "Getting In and Out" chapter).
-_fi__(_GENERIC__)
-_if__(_I960__)
-@node i960-Nindy Remote, EB29K Remote, Mode Options, Starting _GDBN__
-@subsection _GDBN__ with a Remote i960 (Nindy)
-
-@cindex Nindy
-@cindex i960
-@dfn{Nindy} is a ROM Monitor program for Intel 960 target systems.  When
-_GDBN__ is configured to control a remote Intel 960 using Nindy, you can
-tell _GDBN__ how to connect to the 960 in several ways:
-
-@itemize @bullet
-@item
-Through command line options specifying serial port, version of the
-Nindy protocol, and communications speed;
-
-@item
-By responding to a prompt on startup;
-
-@item
-By using the @code{target} command at any point during your _GDBN__
-session.  @xref{Target Commands}.
-
-@end itemize
-
-@menu
-* Nindy Startup::		Startup with Nindy
-* Nindy Options::		Options for Nindy
-* Nindy reset::			Nindy Reset Command
-@end menu
-
-@node Nindy Startup, Nindy Options, i960-Nindy Remote, i960-Nindy Remote
-@subsubsection Startup with Nindy
-
-If you simply start @code{_GDBN__} without using any command-line
-options, you are prompted for what serial port to use, @emph{before} you
-reach the ordinary _GDBN__ prompt:
-@example
-Attach /dev/ttyNN -- specify NN, or "quit" to quit:  
-@end example
-@noindent
-Respond to the prompt with whatever suffix (after @samp{/dev/tty})
-identifies the serial port you want to use.  You can, if you choose,
-simply start up with no Nindy connection by responding to the prompt
-with an empty line.  If you do this, and later wish to attach to Nindy,
-use @code{target} (@pxref{Target Commands}).
-
-@node Nindy Options, Nindy reset, Nindy Startup, i960-Nindy Remote
-@subsubsection Options for Nindy
-
-These are the startup options for beginning your _GDBN__ session with a
-Nindy-960 board attached:
-
-@table @code
-@item -r @var{port}
-Specify the serial port name of a serial interface to be used to connect
-to the target system.  This option is only available when _GDBN__ is
-configured for the Intel 960 target architecture.  You may specify
-@var{port} as any of: a full pathname (e.g. @samp{-r /dev/ttya}), a
-device name in @file{/dev} (e.g. @samp{-r ttya}), or simply the unique
-suffix for a specific @code{tty} (e.g. @samp{-r a}).
-
-@item -O
-(An uppercase letter ``O'', not a zero.)  Specify that _GDBN__ should use
-the ``old'' Nindy monitor protocol to connect to the target system.
-This option is only available when _GDBN__ is configured for the Intel 960
-target architecture.
-
-@quotation
-@emph{Warning:} if you specify @samp{-O}, but are actually trying to
-connect to a target system that expects the newer protocol, the connection
-will fail, appearing to be a speed mismatch.  _GDBN__ will repeatedly
-attempt to reconnect at several different line speeds.  You can abort
-this process with an interrupt.
-@end quotation
-
-@item -brk
-Specify that _GDBN__ should first send a @code{BREAK} signal to the target
-system, in an attempt to reset it, before connecting to a Nindy target.
-
-@quotation
-@emph{Warning:} Many target systems do not have the hardware that this
-requires; it only works with a few boards.
-@end quotation
-
-@end table
-
-The standard @samp{-b} option controls the line speed used on the serial
-port. 
-
-@group
-@node Nindy reset,  , Nindy Options, i960-Nindy Remote
-@subsubsection Nindy Reset Command
-@table @code
-@item reset
-@kindex reset
-For a Nindy target, this command sends a ``break'' to the remote target
-system; this is only useful if the target has been equipped with a
-circuit to perform a hard reset (or some other interesting action) when
-a break is detected.
-@end table
-@end group
-_fi__(_I960__)
-
-_if__(_AMD29K__)
-@node EB29K Remote, VxWorks Remote, i960-Nindy Remote, Starting _GDBN__
-@subsection _GDBN__ with a Remote EB29K
-
-@cindex EB29K board
-@cindex running 29K programs
-
-To use _GDBN__ from a Unix system to run programs on AMD's EB29K
-board in a PC, you must first connect a serial cable between the PC
-and a serial port on the Unix system.  In the following, we assume
-you've hooked the cable between the PC's @file{COM1} port and
-@file{/dev/ttya} on the Unix system.
-
-@menu
-* Comms (EB29K)::		Communications Setup
-* _GDBP__-EB29K::		EB29K cross-debugging
-* Remote Log::			Remote Log
-@end menu
-
-@node Comms (EB29K), _GDBP__-EB29K, EB29K Remote, EB29K Remote
-@subsubsection Communications Setup
-The next step is to set up the PC's port, by doing something like the
-following in DOS on the PC:
-_0__@example
-C:\> MODE com1:9600,n,8,1,none
-_1__@end example
-@noindent
-This example---run on an MS DOS 4.0 system---sets the PC port to 9600
-bps, no parity, eight data bits, one stop bit, and no ``retry'' action;
-you must match the communications parameters when establishing the Unix
-end of the connection as well.
-@c FIXME: Who knows what this "no retry action" crud from the DOS manual may
-@c       mean?  It's optional; leave it out? ---pesch@cygnus.com, 25feb91 
-
-To give control of the PC to the Unix side of the serial line, type
-the following at the DOS console:
-_0__@example
-C:\> CTTY com1
-_1__@end example
-@noindent
-(Later, if you wish to return control to the DOS console, you can use
-the command @code{CTTY con}---but you must send it over the device that
-had control, in our example over the @file{COM1} serial line).
-
-From the Unix host, use a communications program such as @code{tip} or
-@code{cu} to communicate with the PC; for example,
-@example
-cu -s 9600 -l /dev/ttya
-@end example
-@noindent
-The @code{cu} options shown specify, respectively, the linespeed and the
-serial port to use.  If you use @code{tip} instead, your command line
-may look something like the following:
-@example
-tip -9600 /dev/ttya
-@end example
-@noindent
-Your system may define a different name where our example uses
-@file{/dev/ttya} as the argument to @code{tip}.  The communications
-parameters, including what port to use, are associated with the
-@code{tip} argument in the ``remote'' descriptions file---normally the
-system table @file{/etc/remote}.
-@c FIXME: What if anything needs doing to match the "n,8,1,none" part of
-@c the DOS side's comms setup?  cu can support -o (odd
-@c parity), -e (even parity)---apparently no settings for no parity or
-@c for character size.  Taken from stty maybe...?  John points out tip
-@c can set these as internal variables, eg ~s parity=none; man stty
-@c suggests that it *might* work to stty these options with stdin or
-@c stdout redirected... ---pesch@cygnus.com, 25feb91
-
-@kindex EBMON
-Using the @code{tip} or @code{cu} connection, change the DOS working
-directory to the directory containing a copy of your 29K program, then
-start the PC program @code{EBMON} (an EB29K control program supplied
-with your board by AMD).  You should see an initial display from
-@code{EBMON} similar to the one that follows, ending with the
-@code{EBMON} prompt @samp{#}---
-_0__@example
-C:\> G:
-
-G:\> CD \usr\joe\work29k
-
-G:\USR\JOE\WORK29K> EBMON
-Am29000 PC Coprocessor Board Monitor, version 3.0-18
-Copyright 1990 Advanced Micro Devices, Inc.
-Written by Gibbons and Associates, Inc.
-
-Enter '?' or 'H' for help
-
-PC Coprocessor Type   = EB29K
-I/O Base              = 0x208
-Memory Base           = 0xd0000
-
-Data Memory Size      = 2048KB
-Available I-RAM Range = 0x8000 to 0x1fffff
-Available D-RAM Range = 0x80002000 to 0x801fffff
-
-PageSize              = 0x400
-Register Stack Size   = 0x800
-Memory Stack Size     = 0x1800
-
-CPU PRL               = 0x3
-Am29027 Available     = No
-Byte Write Available  = Yes
-
-# ~.
-_1__@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
-running, ready for _GDBN__ to take over.
-
-For this example, we've assumed what is probably the most convenient
-way to make sure the same 29K program is on both the PC and the Unix
-system: a PC/NFS connection that establishes ``drive @code{G:}'' on the
-PC as a file system on the Unix host.  If you don't 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; _GDBN__ will @emph{not} download it over the
-serial line.
-
-@node _GDBP__-EB29K, Remote Log, Comms (EB29K), EB29K Remote
-@subsubsection EB29K cross-debugging
-Finally, @code{cd} to the directory containing an image of your 29K
-program on the Unix system, and start _GDBN__---specifying as argument the
-name of your 29K program:
-@example
-cd /usr/joe/work29k
-_GDBP__ myfoo
-@end example
-Now you can use the @code{target} command:
-@example
-target amd-eb /dev/ttya 9600 MYFOO
-@end example
-@c FIXME: test above 'target amd-eb' as spelled, with caps!  caps are meant to
-@c emphasize that this is the name as seen by DOS (since I think DOS is
-@c single-minded about case of letters).  ---pesch@cygnus.com, 25feb91
-
-@noindent
-In this example, we've assumed your program is in a file called
-@file{myfoo}.  Note that the filename given as the last argument to
-@code{target amd-eb} should be the name of the program as it appears to DOS.
-In our example this is simply @code{MYFOO}, but in general it can include
-a DOS path, and depending on your transfer mechanism may not resemble
-the name on the Unix side.
-
-At this point, you can set any breakpoints you wish; when you're ready
-to see your program run on the 29K board, use the _GDBN__ command
-@code{run}.
-
-To stop debugging the remote program, use the _GDBN__ @code{detach}
-command.  
-
-To return control of the PC to its console, use @code{tip} or @code{cu}
-once again, after your _GDBN__ session has concluded, to attach to
-@code{EBMON}.  You can then type the command @code{q} to shut down
-@code{EBMON}, returning control to the DOS command-line interpreter.
-Type @code{CTTY con} to return command input to the main DOS console,
-and type @kbd{~.} to leave @code{tip} or @code{cu}.
-
-@node Remote Log,  , _GDBP__-EB29K, EB29K Remote
-@subsubsection Remote Log
-@kindex eb.log
-@cindex log file for EB29K
-The @code{target amd-eb} command creates a file @file{eb.log} in the
-current working directory, to help debug problems with the connection.
-@file{eb.log} records all the output from @code{EBMON}, including echoes
-of the commands sent to it.  Running @samp{tail -f} on this file in
-another window often helps to understand trouble with @code{EBMON}, or
-unexpected events on the PC side of the connection.
-_fi__(_AMD29K__)
-
-_if__(_VXWORKS__)
-@node VxWorks Remote,  , EB29K Remote, Starting _GDBN__
-@subsection _GDBN__ and VxWorks
-@cindex VxWorks
-_GDBN__ enables developers to spawn and debug tasks running on networked
-VxWorks targets from a Unix host.  Already-running tasks spawned from
-the VxWorks shell can also be debugged.  _GDBN__ uses code that runs on
-both the UNIX host and on the VxWorks target.  The program
-@code{_GDBP__} is installed and executed on the UNIX host.  
-
-The remote debugging interface (RDB) routines are installed and executed
-on the VxWorks target.  These routines are included in the VxWorks library
-@file{rdb.a} and are incorporated into the system image when source-level
-debugging is enabled in the VxWorks configuration.
-
-@kindex{INCLUDE_RDB}
-Defining @code{INCLUDE_RDB} in the VxWorks configuration file
-@file{configAll.h} includes the RDB interface routines and spawns the
-source debugging task @code{tRdbTask} when VxWorks is booted.  For more
-information on configuring and remaking VxWorks, see the @cite{VxWorks
-Programmer's Guide}.
-
-Once you have included the RDB interface in your VxWorks system image
-and set your Unix execution search path to find _GDBN__, you are ready
-to run _GDBN__.  From your UNIX host, type:
-
-@smallexample
-% _GDBP__
-@end smallexample
-
-_GDBN__ will come up showing the prompt:
-
-@smallexample
-(_GDBP__)
-@end smallexample
-
-@menu
-* VxWorks connection::		Connecting to VxWorks
-* VxWorks download::		VxWorks Download
-* VxWorks attach::		Running Tasks
-@end menu
-
-@node VxWorks connection, VxWorks download, VxWorks Remote, VxWorks Remote
-@subsubsection Connecting to VxWorks
-
-The _GDBN__ command @code{target} lets you connect to a VxWorks target on the
-network.  To connect to a target whose host name is ``@code{tt}'', type:
-
-@smallexample
-(_GDBP__) target vxworks tt
-@end smallexample
-
-_GDBN__ will display a message similar to the following:
-
-@smallexample
-Attaching remote machine across net... Success!
-@end smallexample
-
-_GDBN__ will then attempt to read the symbol tables of any object
-modules loaded into the VxWorks target since it was last booted.
-_GDBN__ locates these files by searching the directories listed in the
-command search path (@pxref{Environment}); if it fails to find an
-object file, it will display a message such as:
-
-@smallexample
-prog.o: No such file or directory.
-@end smallexample
-
-This will cause the @code{target} command to abort.  When this happens,
-you should add the appropriate directory to the search path, with the
-_GDBN__ command @code{path}, and execute the @code{target} command
-again.
-
-@node VxWorks download, VxWorks attach, VxWorks connection, VxWorks Remote
-@subsubsection VxWorks Download
-
-@cindex download to VxWorks
-If you have connected to the VxWorks target and you want to debug an
-object that has not yet been loaded, you can use the _GDBN__ @code{load}
-command to download a file from UNIX to VxWorks incrementally.  The
-object file given as an argument to the @code{load} command is actually
-opened twice: first by the VxWorks target in order to download the code,
-then by _GDBN__ in order to read the symbol table.  This can lead to
-problems if the current working directories on the two systems differ.
-It is simplest to set the working directory on both systems to the
-directory in which the object file resides, and then to reference the
-file by its name, without any path.  Thus, to load a program
-@file{prog.o}, residing in @file{wherever/vw/demo/rdb}, on VxWorks type:
-
-@smallexample
--> cd "wherever/vw/demo/rdb"
-@end smallexample
-
-On _GDBN__ type:
-
-@smallexample
-(_GDBP__) cd wherever/vw/demo/rdb 
-(_GDBP__) load prog.o
-@end smallexample
-
-_GDBN__ will display a response similar to the following:
-
-@smallexample
-Reading symbol data from wherever/vw/demo/rdb/prog.o... done.
-@end smallexample
-
-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 _GDBN__ to 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
-table.)
-
-@node VxWorks attach,  , VxWorks download, VxWorks Remote
-@subsubsection Running Tasks
-
-@cindex running VxWorks tasks
-You can also attach to an existing task using the @code{attach} command as
-follows:
-
-@smallexample
-(_GDBP__) attach @var{task}
-@end smallexample
-
-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
-the time of attachment.
-
-_fi__(_VXWORKS__)
-_if__(_GENERIC__)
-_divert__
-@c end of text diverted to section "Remote Debugging" for general case
-_fi__(_GENERIC__)
-
-@node Leaving _GDBN__, Shell Commands, Starting _GDBN__, Invocation
-@section Leaving _GDBN__
-@cindex exiting _GDBN__
-@table @code
-@item quit
-@kindex quit
-@kindex q
-To exit _GDBN__, use the @code{quit} command (abbreviated @code{q}), or type
-an end-of-file character (usually @kbd{C-d}).  
-@end table
-
-@cindex interrupt
-An interrupt (often @kbd{C-c}) will not exit from _GDBN__, but rather
-will terminate the action of any _GDBN__ command that is in progress and
-return to _GDBN__ command level.  It is safe to type the interrupt
-character at any time because _GDBN__ does not allow it to take effect
-until a time when it is safe.
-
-If you've been using _GDBN__ to control an attached process or device,
-you can release it with the @code{detach} command; @pxref{Attach}.
-
-@node Shell Commands,  , Leaving _GDBN__, Invocation
-@section Shell Commands
-If you just need to execute occasional shell commands during your
-debugging session, there's no need to leave or suspend _GDBN__; you can
-just use the @code{shell} command.
-
-@table @code
-@item shell @var{command string}
-@kindex shell
-@cindex shell escape
-Directs _GDBN__ to invoke an inferior shell to execute @var{command
-string}.  If it exists, the environment variable @code{SHELL} is used
-for the name of the shell to run.  Otherwise _GDBN__ uses
-@code{/bin/sh}.
-@end table
-
-The utility @code{make} is often needed in development environments.
-You don't have to use the @code{shell} command for this purpose in _GDBN__:
-
-@table @code
-@item make @var{make-args}
-@kindex make
-@cindex calling make
-Causes _GDBN__ to execute an inferior @code{make} program with the specified
-arguments.  This is equivalent to @samp{shell make @var{make-args}}.
-@end table
-
-@node Commands, Running, Invocation, Top
-@chapter _GDBN__ Commands
-
-@menu
-* Command Syntax::		Command Syntax
-* Help::			Getting Help
-@end menu
-
-@node Command Syntax, Help, Commands, Commands
-@section Command Syntax
-A _GDBN__ command is a single line of input.  There is no limit on how long
-it can be.  It starts with a command name, which is followed by arguments
-whose meaning depends on the command name.  For example, the command
-@code{step} accepts an argument which is the number of times to step,
-as in @samp{step 5}.  You can also use the @code{step} command with
-no arguments.  Some command names do not allow any arguments.
-
-@cindex abbreviation
-_GDBN__ command names may always be truncated if that abbreviation is
-unambiguous.  Other possible command abbreviations are listed in the
-documentation for individual commands.  Sometimes even ambiguous
-abbreviations are allowed; for example, @code{s} is specially defined as
-equivalent to @code{step} even though there are other commands whose
-names start with @code{s}.
-
-@cindex repeating commands
-A blank line as input to _GDBN__ means to repeat the previous command.
-Certain commands (for example, @code{run}) will not repeat this way;
-these are commands for which unintentional repetition might cause
-trouble and which you are unlikely to want to repeat.
-
-The @code{list} and @code{x} commands construct new arguments when
-repeated, rather than repeating exactly as typed, to permit easy
-scanning of source or memory.
-
-@kindex #
-@cindex comment
-A line of input starting with @kbd{#} is a comment; it does nothing.
-This is useful mainly in command files (@xref{Command Files}).
-
-@node Help,  , Command Syntax, Commands
-@section Getting Help
-@cindex online documentation
-@kindex help
-You can always ask _GDBN__ itself for information on its commands, using the
-command @code{help}.  
-
-@table @code
-@item help
-@itemx h
-@kindex h
-You can use @code{help} (abbreviated @code{h}) with no arguments to
-display a short list of named categories of commands:
-@smallexample
-(_GDBP__) help
-List of classes of commands:
-
-running -- Running the program
-stack -- Examining the stack
-data -- Examining data
-breakpoints -- Making program stop at certain points
-files -- Specifying and examining files
-status -- Status inquiries
-support -- Support facilities
-user-defined -- User-defined commands
-aliases -- Aliases of other commands
-obscure -- Obscure features
-
-Type "help" followed by a class name for a list of commands in that class.
-Type "help" followed by command name for full documentation.
-Command name abbreviations are allowed if unambiguous.
-(_GDBP__) 
-@end smallexample
-
-@item help @var{category}
-Using one of the general help categories as an argument, you can get a
-list of the individual commands in a category.  For example, here is the
-help display for category @code{status}:
-@smallexample
-(_GDBP__) help status
-Status inquiries.
-
-List of commands:
-
-show -- Generic command for showing things set with "set"
-info -- Generic command for printing status
-
-Type "help" followed by command name for full documentation.
-Command name abbreviations are allowed if unambiguous.
-(_GDBP__) 
-@end smallexample
-
-@item help @var{command}
-With a command name as @code{help} argument, _GDBN__ will display a
-short paragraph on how to use that command.  
-@end table
-
-In addition to @code{help}, you can use the _GDBN__ commands @code{info}
-and @code{show} to inquire about the state of your program, or the state
-of _GDBN__ itself.  Both commands support many topics of inquiry; this
-manual introduces each of them in the appropriate context.  The listings
-under @code{info} and under @code{show} in the Index point to
-all the sub-commands.
-@c FIXME: @pxref{Index} used to be here, but even though it shows up in
-@c FIXME...the 'aux' file with a pageno the xref can't find it.  
-
-@table @code
-@item info
-@kindex info
-@kindex i
-This command (abbreviated @code{i}) is for describing the state of your
-program; for example, it can list the arguments given to your program
-(@code{info args}), the registers currently in use (@code{info
-registers}), or the breakpoints you've set (@code{info breakpoints}).
-You can get a complete list of the @code{info} sub-commands with
-@code{help info}.
-
-@kindex show
-@item show
-In contrast, @code{show} is for describing the state of _GDBN__ itself.
-You can change most of the things you can @code{show}, by using the
-related command @code{set}; for example, you can control what number
-system is used for displays with @code{set radix}, or simply inquire
-which is currently in use with @code{show radix}.  
-
-@kindex info set
-To display all the settable parameters and their current
-values, you can use @code{show} with no arguments; you may also use
-@code{info set}.  Both commands produce the same display.
-@c FIXME: "info set" violates the rule that "info" is for state of
-@c FIXME...program.  Ck w/ GNU: "info set" to be called something else,
-@c FIXME...or change desc of rule---eg "state of prog and debugging session"?
-@end table
-
-Here are three miscellaneous @code{show} subcommands, all of which are
-exceptional in lacking corresponding @code{set} commands:
-
-@table @code
-@kindex show version
-@item show version
-Show what version of _GDBN__ is running.  You should include this
-information in _GDBN__ bug-reports.  If multiple versions of _GDBN__ are
-in use at your site, you may occasionally want to make sure what version
-of _GDBN__ you're running; as _GDBN__ evolves, new commands are
-introduced, and old ones may wither away.  The version number is also
-announced when you start _GDBN__ with no arguments.
-
-@kindex show copying
-@item show copying
-Display information about permission for copying _GDBN__.
-
-@kindex show warranty
-@item show warranty
-Display the GNU ``NO WARRANTY'' statement.
-@end table
-
-@node Running, Stopping, Commands, Top
-@chapter Running Programs Under _GDBN__
-
-@menu
-* Compilation::			Compiling for Debugging
-* Starting::			Starting your Program
-* Arguments::			Your Program's Arguments
-* Environment::			Your Program's Environment
-* Working Directory::		Your Program's Working Directory
-* Input/Output::		Your Program's Input and Output
-* Attach::			Debugging an Already-Running Process
-* Kill Process::		Killing the Child Process
-@end menu
-
-@node Compilation, Starting, Running, Running
-@section Compiling for Debugging
-
-In order to debug a program effectively, you need to generate
-debugging information when you compile it.  This debugging information
-is stored in the object file; it describes the data type of each
-variable or function and the correspondence between source line numbers
-and addresses in the executable code.
-
-To request debugging information, specify the @samp{-g} option when you run
-the compiler.
-
-Many C compilers are unable to handle the @samp{-g} and @samp{-O}
-options together.  Using those compilers, you cannot generate optimized
-executables containing debugging information.
-
-The GNU C compiler supports @samp{-g} with or without @samp{-O}, making it
-possible to debug optimized code.  We recommend that you @emph{always} use
-@samp{-g} whenever you compile a program.  You may think the program is
-correct, but there's no sense in pushing your luck.
-
-Some things do not work as well with @samp{-g -O} as with just
-@samp{-g}, particularly on machines with instruction scheduling.  If in
-doubt, recompile with @samp{-g} alone, and if this fixes the problem,
-please report it as a bug (including a test case!).
-
-Older versions of the GNU C compiler permitted a variant option
-@samp{-gg} for debugging information.  _GDBN__ no longer supports this
-format; if your GNU C compiler has this option, do not use it.
-
-@ignore
-@comment As far as I know, there are no cases in which _GDBN__ will
-@comment produce strange output in this case.  (but no promises).
-If your program includes archives made with the @code{ar} program, and
-if the object files used as input to @code{ar} were compiled without the
-@samp{-g} option and have names longer than 15 characters, _GDBN__ will get
-confused reading the program's symbol table.  No error message will be
-given, but _GDBN__ may behave strangely.  The reason for this problem is a
-deficiency in the Unix archive file format, which cannot represent file
-names longer than 15 characters.
-
-To avoid this problem, compile the archive members with the @samp{-g}
-option or use shorter file names.  Alternatively, use a version of GNU
-@code{ar} dated more recently than August 1989.
-@end ignore
-
-
-@node Starting, Arguments, Compilation, Running
-@section Starting your Program
-@cindex starting
-@cindex running
-@table @code
-@item run
-@itemx r
-@kindex run
-Use the @code{run} command to start your program under _GDBN__.
-_if__(_VXWORKS__)
-Except on VxWorks, you
-_fi__(_VXWORKS__)
-_if__(!_VXWORKS__)
-You
-_fi__(!_VXWORKS__)
-must first specify the program name with an argument to _GDBN__
-(@pxref{Invocation}), or using the @code{file} or @code{exec-file}
-command (@pxref{Files}).@refill
-@end table
-
-On targets that support processes, @code{run} creates an inferior
-process and makes that process run your program.  On other targets,
-@code{run} jumps to the start of the program.
-
-The execution of a program is affected by certain information it
-receives from its superior.  _GDBN__ provides ways to specify this
-information, which you must do @i{before} starting the program.  (You
-can change it after starting the program, but such changes will only affect
-the program the next time you start it.)  This information may be
-divided into four categories:
-
-@table @asis
-@item The @i{arguments.}
-You specify the arguments to give your program as the arguments of the
-@code{run} command.  If a shell is available on your target, the shell
-is used to pass the arguments, so that you may use normal conventions
-(such as wildcard expansion or variable substitution) in
-describing the arguments.  In Unix systems, you can control which shell
-is used with the @code{SHELL} environment variable. @xref{Arguments}.@refill
-
-@item The @i{environment.}
-Your program normally inherits its environment from _GDBN__, but you can
-use the _GDBN__ commands @code{set environment} and @code{unset
-environment} to change parts of the environment that will be given to
-the program.  @xref{Environment}.@refill
-
-@item The @i{working directory.}
-Your program inherits its working directory from _GDBN__.  You can set
-_GDBN__'s working directory with the @code{cd} command in _GDBN__.
-@xref{Working Directory}.
-
-@item The @i{standard input and output.}
-Your program normally uses the same device for standard input and
-standard output as _GDBN__ is using.  You can redirect input and output
-in the @code{run} command line, or you can use the @code{tty} command to
-set a different device for your program.
-@xref{Input/Output}.
-@end table
-
-When you issue the @code{run} command, your program begins to execute
-immediately.  @xref{Stopping}, for discussion of how to arrange for your
-program to stop.  Once your program has been started by the @code{run}
-command (and then stopped), you may evaluate expressions that involve
-calls to functions in the inferior, using the @code{print} or
-@code{call} commands.  @xref{Data}.
-
-If the modification time of your symbol file has changed since the last
-time _GDBN__ read its symbols, _GDBN__ will discard its symbol table and re-read
-it.  In this process, it tries to retain your current breakpoints.
-
-@node Arguments, Environment, Starting, Running
-@section Your Program's Arguments
-
-@cindex arguments (to your program)
-The arguments to your program can be specified by the arguments of the
-@code{run} command.  They are passed to a shell, which expands wildcard
-characters and performs redirection of I/O, and thence to the program.
-_GDBN__ uses the shell indicated by your environment variable
-@code{SHELL} if it exists; otherwise, _GDBN__ uses @code{/bin/sh}.
-
-@code{run} with no arguments uses the same arguments used by the previous
-@code{run}, or those set by the @code{set args} command.
-
-@kindex set args
-@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
-with no arguments.  Once you have run your program with arguments, this
-is the only way to run it again without arguments.
-
-@item show args
-@kindex show args
-Show the arguments to give your program when it is started.
-@end table
-
-@node Environment, Working Directory, Arguments, Running
-@section Your Program's Environment
-
-@cindex environment (of your program)
-The @dfn{environment} consists of a set of environment variables and
-their values.  Environment variables conventionally record such things as
-your user name, your home directory, your terminal type, and your search
-path for programs to run.  Usually you set up environment variables with
-the shell and they are inherited by all the other programs you run.  When
-debugging, it can be useful to try running the program with a modified
-environment without having to start _GDBN__ over again.
-
-@table @code
-@item path @var{directory}
-@kindex path
-Add @var{directory} to the front of the @code{PATH} environment variable
-(the search path for executables), for both _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.  You can use the string
-@samp{$cwd} to refer to whatever is the current working directory at the
-time _GDBN__ searches the path.  @footnote{If you use @samp{.} instead,
-it refers to the directory where you executed the @code{path} command.
-_GDBN__ fills in the current path where needed in the @var{directory}
-argument, before adding it to the search path.}
-@c 'path' is explicitly nonrepeatable, but RMS points out it's silly to
-@c document that, since repeating it would be a no-op.
-
-@item show paths
-@kindex show paths
-Display the list of search paths for executables (the @code{PATH}
-environment variable).
-
-@item show environment @var{varname}
-@kindex show environment
-Print the value of environment variable @var{varname} to be given to
-your program when it starts.
-
-@item show environment
-Print the names and values of all environment variables to be given to
-your program.
-
-@item set environment @var{varname} @var{value}
-@itemx set environment @var{varname} = @var{value}
-@kindex set environment
-Sets environment variable @var{varname} to @var{value}.  The value
-changes for your program only, not for _GDBN__ itself.  @var{value} may
-be any string; the values of environment variables are just strings, and
-any interpretation is supplied by your program itself.  The @var{value}
-parameter is optional; if it is eliminated, the variable is set to a
-null value.
-@c "any string" here doesn't include leading, trailing
-@c blanks. Gnu asks: does anyone care?
-
-For example, this command:
-
-@example
-set env USER = foo
-@end example
-
-@noindent
-tells a Unix program, when subsequently run, that its user is named
-@samp{foo}.  (The spaces around @samp{=} are used for clarity here; they
-are not actually required.)
-
-@item unset environment @var{varname}
-@kindex unset environment
-Remove variable @var{varname} from the environment to be passed to your
-program.  This is different from @samp{set env @var{varname} =};
-@code{unset environment} removes the variable from the environment,
-rather than assigning it an empty value.  
-@end table
-
-@node Working Directory, Input/Output, Environment, Running
-@section Your Program's Working Directory
-
-@cindex working directory (of your program)
-Each time you start your program with @code{run}, it inherits its
-working directory from the current working directory of _GDBN__.  _GDBN__'s
-working directory is initially whatever it inherited from its parent
-process (typically the shell), but you can specify a new working
-directory in _GDBN__ with the @code{cd} command.
-
-The _GDBN__ working directory also serves as a default for the commands
-that specify files for _GDBN__ to operate on.  @xref{Files}.
-
-@table @code
-@item cd @var{directory}
-@kindex cd
-Set _GDBN__'s working directory to @var{directory}.
-
-@item pwd
-@kindex pwd
-Print _GDBN__'s working directory.
-@end table
-
-@node Input/Output, Attach, Working Directory, Running
-@section Your Program's Input and Output
-
-@cindex redirection
-@cindex i/o
-@cindex terminal
-@cindex controlling terminal
-By default, the program you run under _GDBN__ does input and output to
-the same terminal that _GDBN__ uses.  _GDBN__ switches the terminal to
-its own terminal modes to interact with you, but it records the terminal
-modes your program was using and switches back to them when you continue
-running your program.
-
-@table @code
-@item info terminal
-@kindex info terminal
-Displays _GDBN__'s recorded information about the terminal modes your
-program is using.
-@end table
-
-You can redirect the program's input and/or output using shell
-redirection with the @code{run} command.  For example,
-
-_0__@example
-run > outfile
-_1__@end example
-
-@noindent
-starts the program, diverting its output to the file @file{outfile}.
-
-@kindex tty
-Another way to specify where the program should do input and output is
-with the @code{tty} command.  This command accepts a file name as
-argument, and causes this file to be the default for future @code{run}
-commands.  It also resets the controlling terminal for the child
-process, for future @code{run} commands.  For example,
-
-@example
-tty /dev/ttyb
-@end example
-
-@noindent
-directs that processes started with subsequent @code{run} commands
-default to do input and output on the terminal @file{/dev/ttyb} and have
-that as their controlling terminal.
-
-An explicit redirection in @code{run} overrides the @code{tty} command's
-effect on the input/output device, but not its effect on the controlling
-terminal.
-
-When you use the @code{tty} command or redirect input in the @code{run}
-command, only the input @emph{for your program} is affected.  The input
-for _GDBN__ still comes from your terminal.
-
-@node Attach, Kill Process, Input/Output, Running
-@section Debugging an Already-Running Process
-@kindex attach
-@cindex attach
-
-@table @code
-@item attach @var{process-id}
-This command
-attaches to a running process---one that was started outside _GDBN__.
-(@code{info files} will show 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
-executing the command.
-@end table
-
-To use @code{attach}, you must be debugging in an environment which
-supports processes.  You must also have permission to send the process a
-signal, and it must have the same effective user ID as the _GDBN__
-process.
-
-When using @code{attach}, you should first use the @code{file} command
-to specify the program running in the process and load its symbol table.
-@xref{Files}.
-
-The first thing _GDBN__ does after arranging to debug the specified
-process is to stop it.  You can examine and modify an attached process
-with all the _GDBN__ commands that ordinarily available when you start
-processes with @code{run}.  You can insert breakpoints; you can step and
-continue; you can modify storage.  If you would rather the process
-continue running, you may use the @code{continue} command after
-attaching _GDBN__ to the process.
-
-@table @code
-@item detach
-@kindex detach
-When you have finished debugging the attached process, you can use the
-@code{detach} command to release it from _GDBN__'s control.  Detaching
-the process continues its execution.  After the @code{detach} command,
-that process and _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
-executing the command.
-@end table
-
-If you exit _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}).
-
-@group
-@node Kill Process,  , Attach, Running
-@section Killing the Child Process
-
-@table @code
-@item kill
-@kindex kill
-Kill the child process in which your program is running under _GDBN__.
-@end table
-
-This command is useful if you wish to debug a core dump instead of a
-running process.  _GDBN__ ignores any core dump file while your program
-is running.
-@end group
-
-On some operating systems, you can't execute your program in another
-process while breakpoints are active inside _GDBN__.  You can use the
-@code{kill} command in this situation to permit running the program
-outside the debugger.
-
-The @code{kill} command is also useful if you wish to recompile and
-relink the program, since on many systems it is impossible to modify an
-executable file which is running in a process.  In this case, when you
-next type @code{run}, _GDBN__ will notice that the file has changed, and
-will re-read the symbol table (while trying to preserve your current
-breakpoint settings).
-
-@node Stopping, Stack, Running, Top
-@chapter Stopping and Continuing
-
-When you run a program normally, it runs until it terminates.  The
-principal purpose of using a debugger is so that you can stop your
-program before it terminates; or so that, if the program runs into
-trouble, you can investigate and find out why.
-
-Inside _GDBN__, your program may stop for any of several reasons, such
-as a signal, a breakpoint, or reaching a new line after a _GDBN__
-command such as @code{step}.  Usually, the messages shown by _GDBN__
-provide ample explanation of the status of your program---but you can
-also explicitly request this information at any time.
-
-@table @code
-@item info program
-@kindex info program
-Display information about the status of your program: whether it is
-running or not, what process it is, and why it stopped.
-@end table
-
-@menu
-* Breakpoints::			Breakpoints, Watchpoints, and Exceptions
-* Stepping::			Stepping
-* Continuing::			Continuing
-* Signals::			Signals
-@end menu
-
-@node Breakpoints, Stepping, Stopping, Stopping
-@section Breakpoints, Watchpoints, and Exceptions
-
-@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 the program will stop.
-You can set breakpoints with the @code{break} command and its variants
-(@pxref{Set Breaks}), to specify the place where the program should stop
-by line number, function name or exact address in the program.  In
-languages with exception handling (such as GNU C++), you can also set
-breakpoints  where an execption is raised (@pxref{Exception Handling}).
-
-@cindex watchpoints
-A @dfn{watchpoint} is a special breakpoint that stops your program when
-the value of an expression changes.  You must use a different command to
-set watchpoints (@pxref{Set Watchpoints}), but aside from that, you can
-manage a watchpoint exactly like any other breakpoint: you enable, disable, and
-delete both breakpoints and watchpoints using exactly the same commands.
-
-Each breakpoint or watchpoint is assigned a number when it is created;
-these numbers are successive integers starting with one.  In many of the
-commands for controlling various features of breakpoints you use the
-breakpoint number to say which breakpoint you want to change.  Each
-breakpoint may be @dfn{enabled} or @dfn{disabled}; if disabled, it has
-no effect on the program until you enable it again.
-
-@menu
-* Set Breaks::			Setting Breakpoints
-* Set Watchpoints::		Setting Watchpoints
-* Exception Handling::		Breakpoints and Exceptions
-* Delete Breaks::		Deleting Breakpoints
-* Disabling::			Disabling Breakpoints
-* Conditions::			Break Conditions
-* Break Commands::		Breakpoint Command Lists
-* Breakpoint Menus::		Breakpoint Menus
-* Error in Breakpoints::	
-@end menu
-
-@node Set Breaks, Set Watchpoints, Breakpoints, Breakpoints
-@subsection Setting Breakpoints
-
-@kindex break
-@kindex b
-Breakpoints are set with the @code{break} command (abbreviated @code{b}).
-
-You have several ways to say where the breakpoint should go.
-
-@table @code
-@item break @var{function}
-Set a breakpoint at entry to function @var{function}.  When using source
-languages that permit overloading of symbols, such as C++,
-@var{function} may refer to more than one possible place to break.
-@xref{Breakpoint Menus}, for a discussion of that situation.
-
-@item break +@var{offset}
-@itemx break -@var{offset}
-Set a breakpoint some number of lines forward or back from the position
-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 the program just before it executes any of the
-code on that line.
-
-@item break @var{filename}:@var{linenum}
-Set a breakpoint at line @var{linenum} in source file @var{filename}.
-
-@item break @var{filename}:@var{function}
-Set a breakpoint at entry to function @var{function} found in file
-@var{filename}.  Specifying a file name as well as a function name is
-superfluous except when multiple files contain similarly named
-functions.
-
-@item break *@var{address}
-Set a breakpoint at address @var{address}.  You can use this to set
-breakpoints in parts of the program which do not have debugging
-information or source files.
-
-@item break
-When called without any arguments, @code{break} sets a breakpoint at the
-next instruction to be executed in the selected stack frame
-(@pxref{Stack}).  In any selected frame but the innermost, this will
-cause the program to 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} doesn't leave an
-active breakpoint.  If you use @code{break} without an argument in the
-innermost frame, _GDBN__ will stop the next time it reaches the current
-location; this may be useful inside loops.
-
-_GDBN__ normally ignores breakpoints when it resumes execution, until at
-least one instruction has been executed.  If it did not do this, you
-would be unable to proceed past a breakpoint without first disabling the
-breakpoint.  This rule applies whether or not the breakpoint already
-existed when the program stopped.
-
-@item break @dots{} if @var{cond}
-Set a breakpoint with condition @var{cond}; evaluate the expression
-@var{cond} each time the breakpoint is reached, and stop only if the
-value is nonzero.  @samp{@dots{}} stands for one of the possible
-arguments described above (or no argument) specifying where to break.
-@xref{Conditions}, for more information on breakpoint conditions.
-
-@item tbreak @var{args}
-@kindex tbreak
-Set a breakpoint enabled only for one stop.  @var{args} are the
-same as in the @code{break} command, and the breakpoint is set in the same
-way, but the breakpoint is automatically disabled the first time it
-is hit.  @xref{Disabling}.
-
-@item rbreak @var{regex}
-@kindex rbreak
-Set a breakpoint on all functions matching @var{regex}.  This is
-useful for setting breakpoints on overloaded functions that are not
-members of any special classes.  This command sets an unconditional
-breakpoint on all matches, printing a list of all breakpoints it set.
-Once these breakpoints are set, they are treated just like the
-breakpoints set with the @code{break} command.  They can be deleted,
-disabled, made conditional, etc., in the standard ways.
-
-@kindex info breakpoints
-@kindex $_
-@item info breakpoints
-The command @code{info breakpoints} prints a list of all breakpoints
-(but not watchpoints) set and not deleted, showing their numbers, where
-in the program they are, and any special features in use for them.
-Disabled breakpoints are included in the list, but marked as disabled.
-@code{info break} with a breakpoint number as argument lists only that
-breakpoint.  The convenience variable @code{$_} and the default
-examining-address for the @code{x} command are set to the address of the
-last breakpoint listed (@pxref{Memory}).  The equivalent command for
-watchpoints is @code{info watch}.
-@end table
-
-_GDBN__ allows you to set any number of breakpoints at the same place in the
-program.  There is nothing silly or meaningless about this.  When the
-breakpoints are conditional, this is even useful (@pxref{Conditions}).
-
-@node Set Watchpoints, Exception Handling, Set Breaks, Breakpoints
-@subsection Setting Watchpoints
-@cindex setting watchpoints
-You can use a watchpoint to stop execution whenever the value of an
-expression changes, without having to predict a particular place in the
-inferior process where this may happen.
-
-Watchpoints currently execute two orders of magnitude more slowly than
-other breakpoints, but this can well be worth it to catch errors where
-you have no clue what part of your program is the culprit.  Some
-processors provide special hardware to implement this feature; future
-releases of _GDBN__ will use such hardware if it is available.
-
-@table @code
-@kindex watch 
-@item watch @var{expr}
-Set a watchpoint for an expression.
-
-@kindex info watchpoints
-@item info watchpoints
-This command prints a list of watchpoints; it is otherwise similar to
-@code{info break}.
-@end table
-
-@node Exception Handling, Delete Breaks, Set Watchpoints, Breakpoints
-@subsection Breakpoints and Exceptions
-@cindex exception handlers
-
-Some languages, such as GNU C++, implement exception handling.  _GDBN__
-can be used to examine what caused the program to raise an exception
-and to list the exceptions the program is prepared to handle at a
-given point in time.
-
-@table @code
-@item catch @var{exceptions}
-@kindex catch
-
-You can set breakpoints at active exception handlers by using the
-@code{catch} command.  @var{exceptions} is a list of names of exceptions
-to catch.
-@end table
-
-You can use @code{info catch} to list active exception handlers;
-@pxref{Frame Info}.
-
-There are currently some limitations to exception handling in _GDBN__.
-These will be corrected in a future release.
-
-@itemize @bullet
-@item
-If you call a function interactively, _GDBN__ 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 the user and cause the program to simply continue
-running until it hits a breakpoint, catches a signal that _GDBN__ is
-listening for, or exits.
-@item
-You cannot raise an exception interactively.
-@item
-You cannot interactively install an exception handler.
-@end itemize
-
-@cindex raise exceptions
-Sometimes @code{catch} is not the best way to debug exception handling:
-if you need to know exactly where an exception is raised, it's better to
-stop @emph{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++ exception are
-raised by calling a library function named @code{__raise_exception}
-which has the following ANSI C interface:
-
-@example
-    /* ADDR is where the exception identifier is stored.
-       ID is the exception identifier.  */
-    void __raise_exception (void **@var{addr}, void *@var{id});
-@end example
-
-@noindent
-To make the debugger catch all exceptions before any stack
-unwinding takes place, set a breakpoint on @code{__raise_exception}
-(@pxref{Breakpoints}).  
-
-With a conditional breakpoint (@xref{Conditions}) that depends on the
-value of @var{id}, you can stop your program when a specific exception
-is raised.  You can use multiple conditional breakpoints to stop the
-program when any of a number of exceptions are raised.
-
-@node Delete Breaks, Disabling, Exception Handling, Breakpoints
-@subsection Deleting Breakpoints
-
-@cindex clearing breakpoints, watchpoints
-@cindex deleting breakpoints, watchpoints
-It is often necessary to eliminate a breakpoint or watchpoint once it
-has done its job and you no longer want the program to stop there.  This
-is called @dfn{deleting} the breakpoint.  A breakpoint that has been
-deleted no longer exists in any sense; it is forgotten.
-
-With the @code{clear} command you can delete breakpoints according to
-where they are in the program.  With the @code{delete} command you can
-delete individual breakpoints or watchpoints by specifying their
-breakpoint numbers.
-
-It is not necessary to delete a breakpoint to proceed past it.  _GDBN__
-automatically ignores breakpoints on the first instruction to be executed
-when you continue execution without changing the execution address.
-
-@table @code
-@item clear
-@kindex clear
-Delete any breakpoints at the next instruction to be executed in the
-selected stack frame (@pxref{Selection}).  When the innermost frame
-is selected, this is a good way to delete a breakpoint that the program
-just stopped at.
-
-@item clear @var{function}
-@itemx clear @var{filename}:@var{function}
-Delete any breakpoints set at entry to the function @var{function}.
-
-@item clear @var{linenum}
-@itemx clear @var{filename}:@var{linenum}
-Delete any breakpoints set at or within the code of the specified line.
-
-@item delete breakpoints @var{bnums}@dots{}
-@itemx delete @var{bnums}@dots{}
-@itemx delete
-@cindex delete breakpoints
-@kindex delete
-@kindex d
-Delete the breakpoints or watchpoints of the numbers specified as
-arguments.  If no argument is specified, delete all breakpoints.  You
-can abbreviate this command as @code{d}.
-@end table
-
-@node Disabling, Conditions, Delete Breaks, Breakpoints
-@subsection Disabling Breakpoints
-
-@cindex disabled breakpoints
-@cindex enabled breakpoints
-Rather than deleting a breakpoint or watchpoint, you might prefer to
-@dfn{disable} it.  This makes the breakpoint inoperative as if it had
-been deleted, but remembers the information on the breakpoint so that
-you can @dfn{enable} it again later.
-
-You disable and enable breakpoints and watchpoints with the
-@code{enable} and @code{disable} commands, optionally specifying one or
-more breakpoint numbers as arguments.  Use @code{info break} or
-@code{info watch} to print a list of breakpoints or watchpoints if you
-don't know which numbers to use.
-
-A breakpoint or watchpoint can have any of four different states of
-enablement:
-
-@itemize @bullet
-@item
-Enabled.  The breakpoint will stop the program.  A breakpoint made
-with the @code{break} command starts out in this state.
-@item
-Disabled.  The breakpoint has no effect on the program.
-@item
-Enabled once.  The breakpoint will stop the program, but
-when it does so it will become disabled.  A breakpoint made
-with the @code{tbreak} command starts out in this state.
-@item
-Enabled for deletion.  The breakpoint will stop the program, but
-immediately after it does so it will be deleted permanently.
-@end itemize
-
-You can use the following commands to enable or disable breakpoints and
-watchpoints:
-
-@table @code
-@item disable breakpoints @var{bnums}@dots{}
-@itemx disable @var{bnums}@dots{}
-@itemx disable
-@kindex disable breakpoints
-@kindex disable
-@kindex dis
-Disable the specified breakpoints---or all breakpoints, if none are
-listed.  A disabled breakpoint has no effect but is not forgotten.  All
-options such as ignore-counts, conditions and commands are remembered in
-case the breakpoint is enabled again later.  You may abbreviate
-@code{disable} as @code{dis}.
-
-@item enable breakpoints @var{bnums}@dots{}
-@itemx enable @var{bnums}@dots{}
-@itemx enable
-@kindex enable breakpoints
-@kindex enable
-Enable the specified breakpoints (or all defined breakpoints).  They
-become effective once again in stopping the program, until you specify
-otherwise.
-
-@item enable breakpoints once @var{bnums}@dots{}
-@itemx enable once @var{bnums}@dots{}
-Enable the specified breakpoints temporarily.  Each will be disabled
-again the next time it stops the program (unless you have used one of
-these commands to specify a different state before that time comes).
-
-@item enable breakpoints delete @var{bnums}@dots{}
-@itemx enable 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 the program
-(unless you have used one of these commands to specify a different
-state before that time comes).
-@end table
-
-Save for a breakpoint set with @code{tbreak} (@pxref{Set Breaks}),
-breakpoints that you set 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 breakpoints;
-@pxref{Stepping}.)
-
-@node Conditions, Break Commands, Disabling, Breakpoints
-@subsection Break Conditions
-@cindex conditional breakpoints
-@cindex breakpoint conditions
-
-The simplest sort of breakpoint breaks every time the program reaches a
-specified place.  You can also specify a @dfn{condition} for a
-breakpoint.  A condition is just a Boolean expression in your
-programming language.  (@xref{Expressions}).  A breakpoint with a
-condition evaluates the expression each time the program reaches it, and
-the program stops only if the condition is true.
-
-Conditions are also accepted for watchpoints; you may not need them,
-since a watchpoint is inspecting the value of an expression anyhow---but
-it might be simpler, say, to just set a watchpoint on a variable name,
-then have a condition that tests whether the new value is an interesting
-one. 
-
-Break conditions may have side effects, and may even call functions in your
-program.  These may sound like strange things to do, but their effects are
-completely predictable unless there is another enabled breakpoint at the
-same address.  (In that case, _GDBN__ might see the other breakpoint first and
-stop the program without checking the condition of this one.)  Note that
-breakpoint commands are usually more convenient and flexible for the
-purpose of performing side effects when a breakpoint is reached
-(@pxref{Break Commands}).
-
-Break conditions can be specified when a breakpoint is set, by using
-@samp{if} in the arguments to the @code{break} command.  @xref{Set Breaks}.
-They can also be changed at any time with the @code{condition} command.
-The @code{watch} command doesn't recognize the @code{if} keyword;
-@code{condition} is the only way to impose a further condition on a
-watchpoint. 
-
-@table @code
-@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
-the program only if the value of @var{expression} is true (nonzero, in
-C).  When you call @code{condition}, the expression you specify is
-checked immediately for syntactic correctness, and to determine whether
-symbols in it have referents in the context of your breakpoint.  _GDBN__
-does not actually evaluate @var{expression} at the time the
-@code{condition} command is given, however.  @xref{Expressions}.
-
-@item condition @var{bnum}
-Remove the condition from breakpoint number @var{bnum}.  It becomes
-an ordinary unconditional breakpoint.
-@end table
-
-@cindex ignore count (of breakpoint)
-A special case of a breakpoint condition is to stop only when the
-breakpoint has been reached a certain number of times.  This is so
-useful that there is a special way to do it, using the @dfn{ignore
-count} of the breakpoint.  Every breakpoint has an ignore count, which
-is an integer.  Most of the time, the ignore count is zero, and
-therefore has no effect.  But if the 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.
-
-@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, _GDBN__
-takes no action.
-
-To make the breakpoint stop the next time it is reached, specify
-a count of zero.
-
-@item continue @var{count}
-@itemx c @var{count}
-@itemx fg @var{count}
-@kindex continue @var{count}
-Continue execution of the program, setting the ignore count of the
-breakpoint that the program stopped at to @var{count} minus one.
-Thus, the program will not stop at this breakpoint until the
-@var{count}'th time it is reached.
-
-An argument to this command is meaningful only when the program stopped
-due to a breakpoint.  At other times, the argument to @code{continue} is
-ignored.
-
-The synonym @code{fg} is provided purely for convenience, and has
-exactly the same behavior as other forms of the command.
-@end table
-
-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.
-
-You could achieve the effect of the ignore count with a
-condition such as _0__@w{@samp{$foo-- <= 0}}_1__ using a debugger convenience
-variable that is decremented each time.  @xref{Convenience Vars}.
-
-@node Break Commands, Breakpoint Menus, Conditions, Breakpoints
-@subsection Breakpoint Command Lists
-
-@cindex breakpoint commands
-You can give any breakpoint (or watchpoint) a series of commands to
-execute when the program stops due to that breakpoint.  For example, you
-might want to print the values of certain expressions, or enable other
-breakpoints.
-
-@table @code
-@item commands @var{bnum}
-@itemx @dots{} @var{command-list} @dots{}
-@itemx end
-@kindex commands
-@kindex end
-Specify a list of commands for breakpoint number @var{bnum}.  The commands
-themselves appear on the following lines.  Type a line containing just
-@code{end} to terminate the commands.
-
-To remove all commands from a breakpoint, use the command
-@code{commands} and follow it immediately by @code{end}; that is, give
-no commands.
-
-With no @var{bnum} argument, @code{commands} refers to the last
-breakpoint or watchpoint set (not to the breakpoint most recently
-encountered).
-@end table
-
-Pressing @key{RET} as a means of repeating the last _GDBN__ command is
-disabled from the time you enter @code{commands} to just after the
-corresponding @code{end}. 
-
-You can use breakpoint commands to start the program up again.  Simply
-use the @code{continue} command, or @code{step}, or any other command to
-resume execution.  However, if you do this, any further commands in the
-same breakpoint's command list are ignored.  When the program stops
-again, _GDBN__ will act according to the cause of that stop.
-
-@kindex silent
-If the first command specified 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 the remaining commands too print nothing, you will see no sign that
-the breakpoint was reached at all.  @code{silent} is not really a command;
-it is meaningful only at the beginning of the commands for a breakpoint.
-
-The commands @code{echo} and @code{output} that allow you to print precisely
-controlled output are often useful in silent breakpoints.  @xref{Output}.
-
-For example, here is how you could use breakpoint commands to print the
-value of @code{x} at entry to @code{foo} whenever @code{x} is positive.
-
-_0__@example
-break foo if x>0
-commands
-silent
-echo x is\040
-output x
-echo \n
-cont
-end
-_1__@end example
-
-One application for breakpoint commands is to correct one bug so you can
-test another.  Put a breakpoint just after the erroneous line of code, give
-it a condition to detect the case in which something erroneous has been
-done, and give it commands to assign correct values to any variables that
-need them.  End with the @code{continue} command so that the program does not
-stop, and start with the @code{silent} command so that no output is
-produced.  Here is an example:
-
-@example
-break 403
-commands
-silent
-set x = y + 4
-cont
-end
-@end example
-
-@cindex lost output
-One deficiency in the operation of automatically continuing breakpoints
-under Unix appears when your program uses raw mode for the terminal.
-_GDBN__ switches back to its own terminal modes (not raw) before executing
-commands, and then must switch back to raw mode when your program is
-continued.  This causes any pending terminal input to be lost. 
-In the GNU system, this will be fixed by changing the behavior of
-terminal modes.
-
-Under Unix, when you have this problem, you might be able to get around
-it by putting your actions into the breakpoint condition instead of
-commands.  For example
-
-@example
-condition 5  (x = y + 4), 0
-@end example
-
-@noindent
-specifies a condition expression (@xref{Expressions}) that will change
-@code{x} as needed, then always have the value zero so the program will not
-stop.  Loss of input is avoided here because break conditions are
-evaluated without changing the terminal modes.  When you want to have
-nontrivial conditions for performing the side effects, the operators
-@samp{&&}, @samp{||} and @samp{?@dots{}:} may be useful.
-
-@node Breakpoint Menus, Error in Breakpoints, Break Commands, Breakpoints
-@subsection Breakpoint Menus
-@cindex C++ overloading
-@cindex symbol overloading
-
-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 _GDBN__ where you want
-a breakpoint.  _GDBN__ responds to this situation by offering you a menu
-of numbered choices for different possible breakpoints, and waiting for
-your selection with the prompt @samp{>}.  The first two
-options are always @samp{[0] cancel} and @samp{[1] all}.  Typing @kbd{1}
-will set a breakpoint at all the definitions available for
-@var{function}, and typing @kbd{0} will abort the @code{break} command
-without setting any new breakpoints.
-
-For example, the following session excerpt shows an attempt to set a
-breakpoint at the overloaded symbol @code{String::after}.  In the
-example, we choose three particular definitions of the function:
-
-@example
-(_GDBP__) b String::after
-[0] cancel
-[1] all
-[2] file:String.cc; line number:867
-[3] file:String.cc; line number:860
-[4] file:String.cc; line number:875
-[5] file:String.cc; line number:853
-[6] file:String.cc; line number:846
-[7] file:String.cc; line number:735
-> 2 4 6
-Breakpoint 1 at 0xb26c: file String.cc, line 867.
-Breakpoint 2 at 0xb344: file String.cc, line 875.
-Breakpoint 3 at 0xafcc: file String.cc, line 846.
-Multiple breakpoints were set.
-Use the "delete" command to delete unwanted breakpoints.
-(_GDBP__) 
-@end example
-
-
-@node Error in Breakpoints,  , Breakpoint Menus, Breakpoints
-@subsection ``Cannot Insert Breakpoints''
-
-@c FIXME: "cannot insert breakpoints" error, v unclear.  
-@c        Q in pending mail to Gilmore. ---pesch@cygnus.com, 26mar91
-Under some operating systems, breakpoints cannot be used in a program if
-any other process is running that program.  In this situation,
-attempting to run or continue a program with a breakpoint will cause _GDBN__
-to stop the other process.
-
-When this happens, you have three ways to proceed:
-
-@enumerate
-@item
-Remove or disable the breakpoints, then continue.
-
-@item
-Suspend _GDBN__, and copy the file containing the program to a new name.
-Resume _GDBN__ and use the @code{exec-file} command to specify that _GDBN__
-should run the program under that name.  Then start the program again.
-
-@c FIXME: RMS commented here "Show example".  Maybe when someone
-@c explains the first FIXME: in this section...
-
-@item
-Relink the program so that the text segment is nonsharable, using the
-linker option @samp{-N}.  The operating system limitation may not apply
-to nonsharable executables.
-@end enumerate
-
-@node Stepping, Continuing, Breakpoints, Stopping
-@section Stepping
-
-@cindex stepping
-@dfn{Stepping} means setting your program in motion for a limited time,
-so that control will return automatically to _GDBN__ after one line of
-code or one machine instruction.  @footnote{Your program might stop even
-sooner, during stepping, since a signal may arrive before your program
-reaches the next source line.  Also, since breakpoints are active during
-stepping, your program will stop for them even if it has not gone as far
-as the stepping command specifies.}
-
-A typical technique for using stepping is to put a breakpoint
-(@pxref{Breakpoints}) at the beginning of the function or the section of
-the program in which a problem is believed to lie, run the program until
-it stops at that breakpoint, and then step through the suspect area,
-examining the variables that are interesting, until you see the problem
-happen.
-
-@table @code
-@item step
-@kindex step
-@kindex s
-Continue running the program until control reaches a different source
-line, then stop it and return control to the debugger.  This command is
-abbreviated @code{s}.
-
-You may use the @code{step} command when control is within a function
-for which there is no debugging information.  In that case, execution
-will proceed until control reaches a different function, or is about to
-return from this function.
-
-@item step @var{count}
-Continue running as in @code{step}, but do so @var{count} times.  If a
-breakpoint is reached or a signal not related to stepping occurs before
-@var{count} steps, stepping stops right away.
-
-@item next
-@kindex next
-@kindex n
-Continue to the next source line in the current stack frame.  Similar to
-@code{step}, but any function calls appearing within the line of code
-are executed without stopping.  Execution stops when control reaches a
-different line of code at the stack level which was executing when the
-@code{next} command was given.  This command is abbreviated @code{n}.
-
-An argument is a repeat count, as in @code{step}.
-
-@code{next} within a function that lacks debugging information acts like
-@code{step}, but any function calls appearing within the code of the
-function are executed without stopping.
-
-@item finish
-@kindex finish
-Continue running until just after the selected stack frame returns (or
-until there is some other reason to stop, such as a fatal signal or a
-breakpoint).  Print the value returned by the selected stack frame (if
-any).
-
-Contrast this with the @code{return} command (@pxref{Returning}).
-
-@item until
-@kindex until
-@item u
-@kindex u
-Continue running until a source line past the current line, in the
-current stack frame, is reached.  This command is used to avoid single
-stepping through a loop more than once.  It is like the @code{next}
-command, except that when @code{until} encounters a jump, it
-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 the 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.
-
-@code{until} always stops the program if it attempts to exit the current
-stack frame.
-
-@code{until} may produce somewhat counterintuitive results if the order
-of the source lines does not match the actual order of execution.  For
-example, in the following excerpt from a debugging session, the @code{f}
-(@code{frame}) command shows that execution is stopped at line
-@code{206}; yet when we use @code{until}, we get to line @code{195}:
-
-@example
-(_GDBP__) f
-#0  main (argc=4, argv=0xf7fffae8) at m4.c:206
-206		    expand_input();
-(_GDBP__) until
-195		for ( ; argc > 0; NEXTARG) @{
-@end example
-
-In this case, (as for any C @code{for}-loop), the loop-step expression
-(here, @samp{argc > 0}) is executed @emph{after} the statements in the
-body of the loop, but is written before them.  Therefore, the
-@code{until} command appeared to step back to the beginning of the loop
-when it advanced to this expression.  However, it has not really gone to
-an earlier statement---not in terms of the actual machine code.
-
-@code{until} with no argument works by means of single
-instruction stepping, and hence is slower than @code{until} with an
-argument.
-
-@item until @var{location}
-@item u @var{location}
-Continue running the program until either the specified location is
-reached, or the current (innermost) stack frame returns.  @var{location}
-is any of the forms of argument acceptable to @code{break} (@pxref{Set
-Breaks}).  This form of the command uses breakpoints, and hence is
-quicker than @code{until} without an argument.
-
-@item stepi
-@itemx si
-@kindex stepi
-@kindex si
-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}.
-
-An argument is a repeat count, as in @code{step}.
-
-@item nexti
-@itemx ni
-@kindex nexti
-@kindex ni
-Execute one machine instruction, but if it is a function call,
-proceed until the function returns.
-
-An argument is a repeat count, as in @code{next}.
-@end table
-
-The @code{continue} command can be used after stepping to resume execution
-until the next breakpoint or signal.
-
-@node Continuing, Signals, Stepping, Stopping
-@section Continuing
-
-After your program stops, most likely you will want it to run some more if
-the bug you are looking for has not happened yet.
-
-@table @code
-@item continue
-@kindex continue
-Continue running the program at the place where it stopped.
-@end table
-
-If the program stopped at a breakpoint, the place to continue running
-is the address of the breakpoint.  You might expect that continuing would
-just stop at the same breakpoint immediately.  In fact, @code{continue}
-takes special care to prevent that from happening.  You do not need
-to disable the breakpoint to proceed through it after stopping there.
-You can, however, specify an ignore-count for the breakpoint that the
-program stopped at, by means of an argument to the @code{continue} command.
-@xref{Conditions}.
-
-If the program stopped because of a signal other than @code{SIGINT} or
-@code{SIGTRAP}, continuing will cause the program to see that signal.
-You may not want this to happen.  For example, if the program stopped
-due to some sort of memory reference error, you might store correct
-values into the erroneous variables and continue, hoping to see more
-execution; but the program would probably terminate immediately as
-a result of the fatal signal once it sees the signal.  To prevent this,
-you can continue with @samp{signal 0}.  @xref{Signaling}.  You can
-also act in advance to control what signals your program will see, using
-the @code{handle} command (@pxref{Signals}). 
-
-@node Signals,  , Continuing, Stopping
-@section Signals
-@cindex signals
-
-A signal is an asynchronous event that can happen in a program.  The
-operating system defines the possible kinds of signals, and gives each
-kind a name and a number.  For example, in Unix @code{SIGINT} is the
-signal a program gets when you type an interrupt (often @kbd{C-c});
-@code{SIGSEGV} is the signal a program gets from referencing a place in
-memory far away from all the areas in use; @code{SIGALRM} occurs when
-the alarm clock timer goes off (which happens only if the program has
-requested an alarm).
-
-@cindex fatal signals
-Some signals, including @code{SIGALRM}, are a normal part of the
-functioning of the program.  Others, such as @code{SIGSEGV}, indicate
-errors; these signals are @dfn{fatal} (kill the program immediately) if the
-program has not specified in advance some other way to handle the signal.
-@code{SIGINT} does not indicate an error in the program, but it is normally
-fatal so it can carry out the purpose of the interrupt: to kill the program.
-
-_GDBN__ has the ability to detect any occurrence of a signal in the program
-running under _GDBN__'s control.  You can tell _GDBN__ in advance what to do for
-each kind of signal.
-
-@cindex handling signals
-Normally, _GDBN__ is set up to ignore non-erroneous signals like @code{SIGALRM}
-(so as not to interfere with their role in the functioning of the program)
-but to stop the program immediately whenever an error signal happens.
-You can change these settings with the @code{handle} command.
-
-@table @code
-@item info signals
-@kindex info signals
-Print a table of all the kinds of signals and how _GDBN__ has been told to
-handle each one.  You can use this to see the signal numbers of all
-the defined types of signals.
-
-@item handle @var{signal} @var{keywords}@dots{}
-@kindex handle
-Change the way _GDBN__ handles signal @var{signal}.  @var{signal} can be the
-number of a signal or its name (with or without the @samp{SIG} at the
-beginning).  The @var{keywords} say what change to make.
-@end table
-
-@group
-The keywords allowed by the @code{handle} command can be abbreviated.
-Their full names are:
-
-@table @code
-@item nostop
-_GDBN__ should not stop the program when this signal happens.  It may
-still print a message telling you that the signal has come in.
-
-@item stop
-_GDBN__ should stop the program when this signal happens.  This implies
-the @code{print} keyword as well.
-
-@item print
-_GDBN__ should print a message when this signal happens.
-
-@item noprint
-_GDBN__ should not mention the occurrence of the signal at all.  This
-implies the @code{nostop} keyword as well.
-
-@item pass
-_GDBN__ should allow the program to see this signal; the program will be
-able to handle the signal, or may be terminated if the signal is fatal
-and not handled.
-
-@item nopass
-_GDBN__ should not allow the program to see this signal.
-@end table
-@end group
-
-When a signal has been set to stop the program, the program cannot see the
-signal until you continue.  It will see the signal then, if @code{pass} is
-in effect for the signal in question @i{at that time}.  In other words,
-after _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
-the program when you later continue it.
-
-You can also use the @code{signal} command to prevent the program from
-seeing a signal, or cause it to see a signal it normally would not see,
-or to give it any signal at any time.  @xref{Signaling}.
-
-
-@node Stack, Source, Stopping, Top
-@chapter Examining the Stack
-
-When your program has stopped, the first thing you need to know is where it
-stopped and how it got there.
-
-@cindex call stack
-Each time your program performs a function call, the information about
-where in the program the call was made from is saved in a block of data
-called a @dfn{stack frame}.  The frame also contains the arguments of the
-call and the local variables of the function that was called.  All the
-stack frames are allocated in a region of memory called the @dfn{call
-stack}.
-
-When your program stops, the _GDBN__ commands for examining the stack allow you
-to see all of this information.
-
-@cindex selected frame
-One of the stack frames is @dfn{selected} by _GDBN__ and many _GDBN__ commands
-refer implicitly to the selected frame.  In particular, whenever you ask
-_GDBN__ for the value of a variable in the program, the value is found in the
-selected frame.  There are special _GDBN__ commands to select whichever frame
-you are interested in.
-
-When the program stops, _GDBN__ automatically selects the currently executing
-frame and describes it briefly as the @code{frame} command does
-(@pxref{Frame Info, Info}).
-
-@menu
-* Frames::			Stack Frames
-* Backtrace::			Backtraces
-* Selection::			Selecting a Frame
-* Frame Info::			Information on a Frame
-@end menu
-
-@node Frames, Backtrace, Stack, Stack
-@section Stack Frames
-
-@cindex frame
-@cindex stack frame
-The call stack is divided up into contiguous pieces called @dfn{stack
-frames}, or @dfn{frames} for short; each frame is the data associated
-with one call to one function.  The frame contains the arguments given
-to the function, the function's local variables, and the address at
-which the function is executing.
-
-@cindex initial frame
-@cindex outermost frame
-@cindex innermost frame
-When your program is started, the stack has only one frame, that of the
-function @code{main}.  This is called the @dfn{initial} frame or the
-@dfn{outermost} frame.  Each time a function is called, a new frame is
-made.  Each time a function returns, the frame for that function invocation
-is eliminated.  If a function is recursive, there can be many frames for
-the same function.  The frame for the function in which execution is
-actually occurring is called the @dfn{innermost} frame.  This is the most
-recently created of all the stack frames that still exist.
-
-@cindex frame pointer
-Inside your program, stack frames are identified by their addresses.  A
-stack frame consists of many bytes, each of which has its own address; each
-kind of computer has a convention for choosing one of those bytes whose
-address serves as the address of the frame.  Usually this address is kept
-in a register called the @dfn{frame pointer register} while execution is
-going on in that frame.
-
-@cindex frame number
-_GDBN__ assigns numbers to all existing stack frames, starting with
-zero for the innermost frame, one for the frame that called it,
-and so on upward.  These numbers do not really exist in your program;
-they are assigned by _GDBN__ to give you a way of designating stack
-frames in _GDBN__ commands.
-
-@cindex frameless execution
-Some compilers allow functions to be compiled so that they operate
-without stack frames.  (For example, the @code{_GCC__} option
-@samp{-fomit-frame-pointer} will generate functions without a frame.)
-This is occasionally done with heavily used library functions to save
-the frame setup time.  _GDBN__ has limited facilities for dealing with
-these function invocations.  If the innermost function invocation has no
-stack frame, _GDBN__ will nevertheless regard it as though it had a
-separate frame, which is numbered zero as usual, allowing correct
-tracing of the function call chain.  However, _GDBN__ has no provision
-for frameless functions elsewhere in the stack.
-
-@node Backtrace, Selection, Frames, Stack
-@section Backtraces
-
-A backtrace is a summary of how the program got where it is.  It shows one
-line per frame, for many frames, starting with the currently executing
-frame (frame zero), followed by its caller (frame one), and on up the
-stack.
-
-@table @code
-@item backtrace
-@itemx bt
-@kindex backtrace
-@kindex bt
-Print a backtrace of the entire stack: one line per frame for all
-frames in the stack.
-
-You can stop the backtrace at any time by typing the system interrupt
-character, normally @kbd{Control-C}.
-
-@item backtrace @var{n}
-@itemx bt @var{n}
-Similar, but print only the innermost @var{n} frames.
-
-@item backtrace -@var{n}
-@itemx bt -@var{n}
-Similar, but print only the outermost @var{n} frames.
-@end table
-
-@kindex where
-@kindex info stack
-@kindex info s
-The names @code{where} and @code{info stack} (abbreviated @code{info s})
-are additional aliases for @code{backtrace}.
-
-Each line in the backtrace shows the frame number and the function name.
-The program counter value is also shown---unless you use @code{set
-print address off}.  The backtrace also shows the source file name and
-line number, as well as the arguments to the function.  The program
-counter value is omitted if it is at the beginning of the code for that
-line number.
-
-Here is an example of a backtrace.  It was made with the command
-@samp{bt 3}, so it shows the innermost three frames.
-
-@smallexample
-@group
-#0  m4_traceon (obs=0x24eb0, argc=1, argv=0x2b8c8) at builtin.c:993
-#1  0x6e38 in expand_macro (sym=0x2b600) at macro.c:242
-#2  0x6840 in expand_token (obs=0x0, t=177664, td=0xf7fffb08)
-    at macro.c:71
-(More stack frames follow...)
-@end group
-@end smallexample
-
-@noindent
-The display for frame zero doesn't begin with a program counter
-value, indicating that the program has stopped at the beginning of the
-code for line @code{993} of @code{builtin.c}.
-
-@node Selection, Frame Info, Backtrace, Stack
-@section Selecting a Frame
-
-Most commands for examining the stack and other data in the program work on
-whichever stack frame is selected at the moment.  Here are the commands for
-selecting a stack frame; all of them finish by printing a brief description
-of the stack frame just selected.
-
-@table @code
-@item frame @var{n}
-@itemx f @var{n}
-@kindex frame
-@kindex f
-Select frame number @var{n}.  Recall that frame zero is the innermost
-(currently executing) frame, frame one is the frame that called the
-innermost one, and so on.  The highest-numbered frame is @code{main}'s
-frame.
-
-@item frame @var{addr}
-@itemx f @var{addr}
-Select the frame at address @var{addr}.  This is useful mainly if the
-chaining of stack frames has been damaged by a bug, making it
-impossible for _GDBN__ to assign numbers properly to all frames.  In
-addition, this can be useful when the program has multiple stacks and
-switches between them.
-
-_if_(_SPARC__)
-On the SPARC architecture, @code{frame} needs two addresses to
-select an arbitrary frame: a frame pointer and a stack pointer.  
-@c note to future updaters: this is conditioned on a flag
-@c FRAME_SPECIFICATION_DYADIC in the tm-*.h files, currently only used
-@c by SPARC, hence the specific attribution.  Generalize or list all
-@c possibilities if more supported machines start doing this.
-_fi_(_SPARC__)
-
-@item up @var{n}
-@kindex up
-Move @var{n} frames up the stack.  For positive numbers @var{n}, this
-advances toward the outermost frame, to higher frame numbers, to frames
-that have existed longer.  @var{n} defaults to one.
-
-@item down @var{n}
-@kindex down
-@kindex do
-Move @var{n} frames down the stack.  For positive numbers @var{n}, this
-advances toward the innermost frame, to lower frame numbers, to frames
-that were created more recently.  @var{n} defaults to one.  You may
-abbreviate @code{down} as @code{do}.
-@end table
-
-All of these commands end by printing two lines of output describing the
-frame.  The first line shows the frame number, the function name, the
-arguments, and the source file and line number of execution in that
-frame.  The second line shows the text of that source line.  For
-example:
-
-@smallexample
-(_GDBP__) up
-#1  0x22f0 in main (argc=1, argv=0xf7fffbf4, env=0xf7fffbfc) at env.c:10
-10              read_input_file (argv[i]);
-@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.  @xref{List}.
-
-@table @code
-@item up-silently @var{n}
-@itemx down-silently @var{n}
-@kindex down-silently
-@kindex up-silently
-These two commands are variants of @code{up} and @code{down},
-respectively; they differ in that they do their work silently, without
-causing display of the new frame.  They are intended primarily for use
-in _GDBN__ command scripts, where the output might be unnecessary and
-distracting. 
-
-@end table
-
-@node Frame Info,  , Selection, Stack
-@section Information About a Frame
-
-There are several other commands to print information about the selected
-stack frame.
-
-@table @code
-@item frame
-@itemx f
-When used without any argument, this command does not change which frame
-is selected, but prints a brief description of the currently
-selected stack frame.  It can be abbreviated @code{f}.  With an
-argument, this command is used to select a stack frame (@pxref{Selection}).
-
-@item info frame
-@kindex info frame
-@itemx info f
-@kindex info f
-This command prints a verbose description of the selected stack frame,
-including the address of the frame, the addresses of the next frame down
-(called by this frame) and the next frame up (caller of this frame),
-the address of the frame's arguments, the program counter saved in it
-(the address of execution in the caller frame), and which registers
-were saved in the frame.  The verbose description is useful when
-something has gone wrong that has made the stack format fail to fit
-the usual conventions.
-
-@item info frame @var{addr}
-@itemx info f @var{addr}
-Print a verbose description of the frame at address @var{addr},
-without selecting that frame.  The selected frame remains unchanged by
-this command.
-
-@item info args
-@kindex info args
-Print the arguments of the selected frame, each on a separate line.
-
-@item info locals
-@kindex info locals
-Print the local variables of the selected frame, each on a separate
-line.  These are all variables declared static or automatic within all
-program blocks that execution in this frame is currently inside of.
-
-@item info catch
-@kindex info catch
-@cindex catch exceptions
-@cindex exception handlers
-Print a list of all the exception handlers that are active in the
-current stack frame at the current point of execution.  To see other
-exception handlers, visit the associated frame (using the @code{up},
-@code{down}, or @code{frame} commands); then type @code{info catch}.
-@xref{Exception Handling}.
-@end table
-
-@node Source, Data, Stack, Top
-@chapter Examining Source Files
-
-_GDBN__ can print parts of your program's source, since the debugging
-information recorded in your program tells _GDBN__ what source files
-were used to built it.  When your program stops, _GDBN__ spontaneously
-prints the line where it stopped.  Likewise, when you select a stack
-frame (@pxref{Selection}), _GDBN__ prints the line where execution in
-that frame has stopped.  You can print other portions of source files by
-explicit command.
-
-If you use _GDBN__ through its GNU Emacs interface, you may prefer to
-use Emacs facilities to view source; @pxref{Emacs}.
-
-@menu
-* List::			Printing Source Lines
-* Search::			Searching Source Files
-* Source Path::			Specifying Source Directories
-* Machine Code::		Source and Machine Code
-@end menu
-
-@node List, Search, Source, Source
-@section Printing Source Lines
-
-@kindex list
-@kindex l
-To print lines from a source file, use the @code{list} command
-(abbreviated @code{l}).  There are several ways to specify what part
-of the file you want to print.
-
-Here are the forms of the @code{list} command most commonly used:
-
-@table @code
-@item list @var{linenum}
-Print ten lines centered around line number @var{linenum} in the
-current source file.
-
-@item list @var{function}
-Print ten lines centered around the beginning of function
-@var{function}.
-
-@item list
-Print ten more lines.  If the last lines printed were printed with a
-@code{list} command, this prints ten lines following the last lines
-printed; however, if the last line printed was a solitary line printed
-as part of displaying a stack frame (@pxref{Stack}), this prints ten
-lines centered around that line.
-
-@item list -
-Print ten lines just before the lines last printed.
-@end table
-
-Repeating a @code{list} command with @key{RET} discards the argument,
-so it is equivalent to typing just @code{list}.  This is more useful
-than listing the same lines again.  An exception is made for an
-argument of @samp{-}; that argument is preserved in repetition so that
-each repetition moves up in the source file.
-
-@cindex linespec
-In general, the @code{list} command expects you to supply zero, one or two
-@dfn{linespecs}.  Linespecs specify source lines; there are several ways
-of writing them but the effect is always to specify some source line.
-Here is a complete description of the possible arguments for @code{list}:
-
-@table @code
-@item list @var{linespec}
-Print ten lines centered around the line specified by @var{linespec}.
-
-@item list @var{first},@var{last}
-Print lines from @var{first} to @var{last}.  Both arguments are
-linespecs.
-
-@item list ,@var{last}
-Print ten lines ending with @var{last}.
-
-@item list @var{first},
-Print ten lines starting with @var{first}.
-
-@item list +
-Print ten lines just after the lines last printed.
-
-@item list -
-Print ten lines just before the lines last printed.
-
-@item list
-As described in the preceding table.
-@end table
-
-Here are the ways of specifying a single source line---all the
-kinds of linespec.
-
-@table @code
-@item @var{number}
-Specifies line @var{number} of the current source file.
-When a @code{list} command has two linespecs, this refers to
-the same source file as the first linespec.
-
-@item +@var{offset}
-Specifies the line @var{offset} lines after the last line printed.
-When used as the second linespec in a @code{list} command that has
-two, this specifies the line @var{offset} lines down from the
-first linespec.
-
-@item -@var{offset}
-Specifies the line @var{offset} lines before the last line printed.
-
-@item @var{filename}:@var{number}
-Specifies line @var{number} in the source file @var{filename}.
-
-@item @var{function}
-@c FIXME: "of the open-brace" is C-centric.  When we add other langs...
-Specifies the line of the open-brace that begins the body of the
-function @var{function}.
-
-@item @var{filename}:@var{function}
-Specifies the line of the open-brace that begins the body of the
-function @var{function} in the file @var{filename}.  You only need the
-file name with a function name to avoid ambiguity when there are
-identically named functions in different source files.
-
-@item *@var{address}
-Specifies the line containing the program address @var{address}.
-@var{address} may be any expression.
-@end table
-
-@node Search, Source Path, List, Source
-@section Searching Source Files
-@cindex searching
-@kindex reverse-search
-
-There are two commands for searching through the current source file for a
-regular expression.
-
-@table @code
-@item forward-search @var{regexp}
-@itemx search @var{regexp}
-@kindex search
-@kindex forward-search
-The command @samp{forward-search @var{regexp}} checks each line, starting
-with the one following the last line listed, for a match for @var{regexp}.
-It lists the line that is found.  You can abbreviate the command name
-as @code{fo}.  The synonym @samp{search @var{regexp}} is also supported.
-
-@item reverse-search @var{regexp}
-The command @samp{reverse-search @var{regexp}} checks each line, starting
-with the one before the last line listed and going backward, for a match
-for @var{regexp}.  It lists the line that is found.  You can abbreviate
-this command as @code{rev}.
-@end table
-
-@node Source Path, Machine Code, Search, Source
-@section Specifying Source Directories
-
-@cindex source path
-@cindex directories for source files
-Executable programs sometimes do not record the directories of the source
-files from which they were compiled, just the names.  Even when they do,
-the directories could be moved between the compilation and your debugging
-session.  _GDBN__ has a list of directories to search for source files;
-this is called the @dfn{source path}.  Each time _GDBN__ wants a source file,
-it tries all the directories in the list, in the order they are present
-in the list, until it finds a file with the desired name.  Note that
-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 _GDBN__ can't find a source file in the source path, and the object
-program records a directory, _GDBN__ tries that directory too.  If the
-source path is empty, and there is no record of the compilation
-directory, _GDBN__ will, as a last resort, look in the current
-directory.
-
-Whenever you reset or rearrange the source path, _GDBN__ will clear out
-any information it has cached about where source files are found, where
-each line is in the file, etc.
-
-@kindex directory
-When you start _GDBN__, its source path is empty.
-To add other directories, use the @code{directory} command.
-
-@table @code
-@item directory @var{dirname} @dots{}
-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.  You can use
-the string @samp{$cdir} to refer to the compilation directory (if one is
-recorded), and @samp{$cwd} to refer to the current working directory.
-@footnote{@samp{$cwd} is not the same as @samp{.}---the former tracks
-the current working directory as it changes during your _GDBN__ session,
-while the latter is immediately expanded to the current directory at the
-time you add an entry to the source path.}
-
-@item directory
-Reset the source path to empty again.  This requires confirmation.
-
-@c RET-repeat for @code{directory} is explicitly disabled, but since
-@c repeating it would be a no-op we don't say that.  (thanks to RMS)
-
-@item show directories
-@kindex show directories
-Print the source path: show which directories it contains.
-@end table
-
-If your source path is cluttered with directories that are no longer of
-interest, _GDBN__ may sometimes cause confusion by finding the wrong
-versions of source.  You can correct the situation as follows:
-
-@enumerate
-@item
-Use @code{directory} with no argument to reset the source path to empty.
-
-@item
-Use @code{directory} with suitable arguments to reinstall the
-directories you want in the source path.  You can add all the
-directories in one command.
-@end enumerate
-
-@node Machine Code,  , Source Path, Source
-@section Source and Machine Code
-You can use the command @code{info line} to map source lines to program
-addresses (and viceversa), and the command @code{disassemble} to display
-a range of addresses as machine instructions.
-
-@table @code
-@item info line @var{linespec}
-@kindex info line
-Print the starting and ending addresses of the compiled code for
-source line @var{linespec}.  You can specify source lines in any of the
-ways understood by the @code{list} command (@pxref{List}).
-@end table
-
-For example, we can use @code{info line} to inquire on where the object
-code for the first line of function @code{m4_changequote} lies:
-@smallexample
-(_GDBP__) info line m4_changecom
-Line 895 of "builtin.c" starts at pc 0x634c and ends at 0x6350.
-@end smallexample
-
-@noindent
-We can also inquire (using @code{*@var{addr}} as the form for
-@var{linespec}) what source line covers a particular address:
-@smallexample
-(_GDBP__) info line *0x63ff
-Line 926 of "builtin.c" starts at pc 0x63e4 and ends at 0x6404.
-@end smallexample
-
-@kindex $_
-After @code{info line}, the default address for the @code{x}
-command is changed to the starting address of the line, so that
-@samp{x/i} is sufficient to begin examining the machine code
-(@pxref{Memory}).  Also, this address is saved as the value of the
-convenience variable @code{$_} (@pxref{Convenience Vars}).
-
-@table @code
-@kindex disassemble
-@item disassemble
-This specialized command is provided to dump 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 (separated by one
-or more spaces) specify a range of addresses (first inclusive, second
-exclusive) to be dumped.  
-@end table
-
-We can use @code{disassemble} to inspect the object code
-range shown in the last @code{info line} example:
-
-@smallexample
-(_GDBP__) disas 0x63e4 0x6404
-Dump of assembler code from 0x63e4 to 0x6404:
-0x63e4 <builtin_init+5340>:	ble 0x63f8 <builtin_init+5360>
-0x63e8 <builtin_init+5344>:	sethi %hi(0x4c00), %o0
-0x63ec <builtin_init+5348>:	ld [%i1+4], %o0
-0x63f0 <builtin_init+5352>:	b 0x63fc <builtin_init+5364>
-0x63f4 <builtin_init+5356>:	ld [%o0+4], %o0
-0x63f8 <builtin_init+5360>:	or %o0, 0x1a4, %o0
-0x63fc <builtin_init+5364>:	call 0x9288 <path_search>
-0x6400 <builtin_init+5368>:	nop 
-End of assembler dump.
-(_GDBP__) 
-
-@end smallexample
-
-@node Data, Symbols, Source, Top
-@chapter Examining Data
-
-@cindex printing data
-@cindex examining data
-@kindex print
-@kindex inspect
-@c "inspect" isn't quite a synonym if you're using Epoch, which we don't
-@c document because it's nonstandard...  Under Epoch it displays in a
-@c different window or something like that.
-The usual way to examine data in your program is with the @code{print}
-command (abbreviated @code{p}), or its synonym @code{inspect}.  It
-evaluates and prints the value of any valid expression of the language
-the program is written in (for now, C or C++).  You type
-
-@example
-print @var{exp}
-@end example
-
-@noindent
-where @var{exp} is any valid expression (in the source language), and
-the value of @var{exp} is printed in a format appropriate to its data
-type.
-
-A more low-level way of examining data is with the @code{x} command.
-It examines data in memory at a specified address and prints it in a
-specified format.  @xref{Memory}.
-
-@menu
-* Expressions::			Expressions
-* Variables::			Program Variables
-* Arrays::			Artificial Arrays
-* Output formats::		Output formats
-* Memory::			Examining Memory
-* Auto Display::		Automatic Display
-* Print Settings::		Print Settings
-* Value History::		Value History
-* Convenience Vars::		Convenience Variables
-* Registers::			Registers
-* Floating Point Hardware::	Floating Point Hardware
-@end menu
-
-@node Expressions, Variables, Data, Data
-@section Expressions
 
-@cindex expressions
-@code{print} and many other _GDBN__ commands accept an expression and
-compute its value.  Any kind of constant, variable or operator defined
-by the programming language you are using is legal in an expression in
-_GDBN__.  This includes conditional expressions, function calls, casts
-and string constants.  It unfortunately does not include symbols defined
-by preprocessor @code{#define} commands, or C++ expressions involving
-@samp{::}, the name resolution operator.
-@c FIXME: actually C++ a::b works except in obscure circumstances where it
-@c FIXME...can conflict with GDB's own name scope resolution.
-
-Casts are supported in all languages, not just in C, because it is so
-useful to cast a number into a pointer so as to examine a structure
-at that address in memory.
-
-_GDBN__ supports three kinds of operator in addition to those of programming
-languages:
-
-@table @code
-@item @@
-@samp{@@} is a binary operator for treating parts of memory as arrays.
-@xref{Arrays}, for more information.
-
-@item ::
-@samp{::} allows you to specify a variable in terms of the file or
-function where it is defined.  @xref{Variables}.
-
-@item @{@var{type}@} @var{addr}
-Refers to an object of type @var{type} stored at address @var{addr} in
-memory.  @var{addr} may be any expression whose value is an integer or
-pointer (but parentheses are required around binary operators, just as in
-a cast).  This construct is allowed regardless of what kind of data is
-normally supposed to reside at @var{addr}.@refill
-@end table
-
-@node Variables, Arrays, Expressions, Data
-@section Program Variables
-
-The most common kind of expression to use is the name of a variable
-in your program.
-
-Variables in expressions are understood in the selected stack frame
-(@pxref{Selection}); they must either be global (or static) or be visible
-according to the scope rules of the programming language from the point of
-execution in that frame.  This means that in the function
-
-@example
-foo (a)
-     int a;
-@{
-  bar (a);
-  @{
-    int b = test ();
-    bar (b);
-  @}
-@}
-@end example
-
-@noindent
-the variable @code{a} is usable whenever the program is executing
-within the function @code{foo}, but the variable @code{b} is visible
-only while the program is executing inside the block in which @code{b}
-is declared.
-
-@cindex variable name conflict
-There is an exception: you can refer to a variable or function whose
-scope is a single source file even if the current execution point is not
-in this file.  But it is possible to have more than one such variable or
-function with the same name (in different source files).  If that happens,
-referring to that name has unpredictable effects.  If you wish, you can
-specify a variable in a particular file, using the colon-colon notation:
-
-@cindex colon-colon
-@kindex ::
-@example
-@var{file}::@var{variable}
-@end example
-
-@noindent
-Here @var{file} is the name of the source file whose variable you want.
-
-@cindex C++ name resolution
-This use of @samp{::} is very rarely in conflict with the very similar
-use of the same notation in C++.  _GDBN__ also supports use of the C++
-name resolution operator in _GDBN__ expressions.
-
-@node Arrays, Output formats, Variables, Data
-@section Artificial Arrays
-
-@cindex artificial array
-@kindex @@
-It is often useful to print out several successive objects of the
-same type in memory; a section of an array, or an array of
-dynamically determined size for which only a pointer exists in the
-program.
-
-This can be done by constructing an @dfn{artificial array} with the
-binary operator @samp{@@}.  The left operand of @samp{@@} should be
-the first element of the desired array, as an individual object.
-The right operand should be the desired length of the array.  The result is
-an array value whose elements are all of the type of the left argument.
-The first element is actually the left argument; the second element
-comes from bytes of memory immediately following those that hold the
-first element, and so on.  Here is an example.  If a program says
-
-@example
-int *array = (int *) malloc (len * sizeof (int));
-@end example
-
-@noindent
-you can print the contents of @code{array} with
-
-@example
-p *array@@len
-@end example
-
-The left operand of @samp{@@} must reside in memory.  Array values made
-with @samp{@@} in this way behave just like other arrays in terms of
-subscripting, and are coerced to pointers when used in expressions.
-Artificial arrays most often appear in expressions via the value history
-(@pxref{Value History}), after printing one out.)
-
-@node Output formats, Memory, Arrays, Data
-@section Output formats
-
-@cindex formatted output
-@cindex output formats
-By default, _GDBN__ prints a value according to its data type.  Sometimes
-this is not what you want.  For example, you might want to print a number
-in hex, or a pointer in decimal.  Or you might want to view data in memory
-at a certain address as a character string or as an instruction.  To do
-these things, specify an @dfn{output format} when you print a value.
-
-The simplest use of output formats is to say how to print a value
-already computed.  This is done by starting the arguments of the
-@code{print} command with a slash and a format letter.  The format
-letters supported are:
-
-@table @code
-@item x
-Regard the bits of the value as an integer, and print the integer in
-hexadecimal.
-
-@item d
-Print as integer in signed decimal.
-
-@item u
-Print as integer in unsigned decimal.
-
-@item o
-Print as integer in octal.
-
-@item t
-Print as integer in binary.  The letter @samp{t} stands for ``two''.
-
-@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:
-@example
-(_GDBP__) p/a 0x54320
-_0__$3 = 0x54320 <_initialize_vx+396>_1__
-@end example
-
-
-@item c
-Regard as an integer and print it as a character constant.
-
-@item f
-Regard the bits of the value as a floating point number and print
-using typical floating point syntax.
-@end table
-
-For example, to print the program counter in hex (@pxref{Registers}), type
-
-@example
-p/x $pc
-@end example
-
-@noindent
-Note that no space is required before the slash; this is because command
-names in _GDBN__ cannot contain a slash.
-
-To reprint the last value in the value history with a different format,
-you can use the @code{print} command with just a format and no
-expression.  For example, @samp{p/x} reprints the last value in hex.
-
-@node Memory, Auto Display, Output formats, Data
-@section Examining Memory
-
-@cindex examining memory
-@table @code
-@kindex x
-@item x/@var{nfu} @var{expr}
-The command @code{x} (for `examine') can be used to examine memory
-without being constrained by your program's data types.  You can specify
-the unit size @var{u} of memory to inspect, and a repeat count @var{n} of how
-many of those units to display.  @code{x} understands the formats
-@var{f} used by @code{print}; two additional formats, @samp{s} (string)
-and @samp{i} (machine instruction) can be used without specifying a unit
-size.
-@end table
-
-For example, @samp{x/3uh 0x54320} is a request to display three halfwords
-(@code{h}) of memory, formatted as unsigned decimal integers (@samp{u}),
-starting at address @code{0x54320}.  @samp{x/4xw $sp} prints the four
-words (@samp{w}) of memory above the stack pointer (here, @samp{$sp};
-@pxref{Registers}) in hexadecimal (@samp{x}).
-
-Since the letters indicating unit sizes are all distinct from the
-letters specifying output formats, you don't have to remember whether
-unit size or format comes first; either order will work.  The output
-specifications @samp{4xw} and @samp{4wx} mean exactly the same thing.
-
-After the format specification, you supply an expression for the address
-where _GDBN__ is to begin reading from memory.  The expression need not
-have a pointer value (though it may); it is always interpreted as an
-integer address of a byte of memory.  @xref{Expressions} for more
-information on expressions.
-
-These are the memory units @var{u} you can specify with the @code{x}
-command:
-
-@table @code
-@item b
-Examine individual bytes.
-
-@item h
-Examine halfwords (two bytes each).
-
-@item w
-Examine words (four bytes each).
-
-@cindex word
-Many assemblers and cpu designers still use `word' for a 16-bit quantity,
-as a holdover from specific predecessor machines of the 1970's that really
-did use two-byte words.  But more generally the term `word' has always
-referred to the size of quantity that a machine normally operates on and
-stores in its registers.  This is 32 bits for all the machines that _GDBN__
-runs on.
-
-@item g
-Examine giant words (8 bytes).
-@end table
-
-You can combine these unit specifications with any of the formats
-described for @code{print}.  @xref{Output formats}.
-
-@code{x} has two additional output specifications which derive the unit
-size from the data inspected:
-
-@table @code
-@item s
-Print a null-terminated string of characters.  Any explicitly specified
-unit size is ignored; instead, the unit is however many bytes it takes
-to reach a null character (including the null character).
-
-@item i
-Print a machine instruction in assembler syntax (or nearly).  Any
-specified unit size is ignored; the number of bytes in an instruction
-varies depending on the type of machine, the opcode and the addressing
-modes used.  The command @code{disassemble} gives an alternative way of
-inspecting machine instructions.  @xref{Machine Code}.
-@end table
-
-If you omit either the format @var{f} or the unit size @var{u}, @code{x}
-will use the same one that was used last.  If you don't use any letters
-or digits after the slash, you can omit the slash as well.
-
-You can also omit the address to examine.  Then the address used is just
-after the last unit examined.  This is why string and instruction
-formats actually compute a unit-size based on the data: so that the next
-string or instruction examined will start in the right place.  
-
-When the @code{print} command shows a value that resides in memory,
-@code{print} also sets the default address for the @code{x} command.
-@code{info line} also sets the default for @code{x}, to the address of
-the start of the machine code for the specified line (@pxref{Machine
-Code}), and @code{info breakpoints} sets it to the address of the last
-breakpoint listed (@pxref{Set Breaks}).
-
-When you use @key{RET} to repeat an @code{x} command, the address
-specified previously (if any) is ignored, so that the repeated command
-examines the successive locations in memory rather than the same ones.
-
-You can examine several consecutive units of memory with one command by
-writing a repeat-count after the slash (before the format letters, if
-any).  Omitting the repeat count @var{n} displays one unit of the
-appropriate size.  The repeat count must be a decimal integer.  It has
-the same effect as repeating the @code{x} command @var{n} times except
-that the output may be more compact, with several units per line.  For
-example,
-
-@example
-x/10i $pc
-@end example
-
-@noindent
-prints ten instructions starting with the one to be executed next in the
-selected frame.  After doing this, you could print a further seven
-instructions with
-
-@example
-x/7
-@end example
-
-@noindent
----where the format and address are allowed to default.
-
-@kindex $_
-@kindex $__
-The addresses and contents printed by the @code{x} command are not put
-in the value history because there is often too much of them and they
-would get in the way.  Instead, _GDBN__ makes these values available for
-subsequent use in expressions as values of the convenience variables
-@code{$_} and @code{$__}.  After an @code{x} command, the last address
-examined is available for use in expressions in the convenience variable
-@code{$_}.  The contents of that address, as examined, are available in
-the convenience variable @code{$__}.
-
-If the @code{x} command has a repeat count, the address and contents saved
-are from the last memory unit printed; this is not the same as the last
-address printed if several units were printed on the last line of output.
-
-@node Auto Display, Print Settings, Memory, Data
-@section Automatic Display
-@cindex automatic display
-@cindex display of expressions
-
-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 _GDBN__ will print its value each time the 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:
-
-@example
-2: foo = 38
-3: bar[5] = (struct hack *) 0x3804
-@end example
-
-@noindent
-showing item numbers, expressions and their current values.  As with
-displays you request manually using @code{x} or @code{print}, you can
-specify the output format you prefer; in fact, @code{display} decides
-whether to use @code{print} or @code{x} depending on how elaborate your
-format specification is---it uses @code{x} if you specify a unit size,
-or one of the two formats (@samp{i} and @samp{s}) that are only
-supported by @code{x}; otherwise it uses @code{print}.
-
-@table @code
-@item display @var{exp}
-@kindex display
-Add the expression @var{exp} to the list of expressions to display
-each time the program stops.  @xref{Expressions}.
-
-@code{display} will 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
-count, add the expression @var{exp} to the auto-display list but
-arranges to display it each time in the specified format @var{fmt}.
-@xref{Output formats}.
-
-@item display/@var{fmt} @var{addr}
-For @var{fmt} @samp{i} or @samp{s}, or including a unit-size or a
-number of units, add the expression @var{addr} as a memory address to
-be examined each time the program stops.  Examining means in effect
-doing @samp{x/@var{fmt} @var{addr}}.  @xref{Memory}.
-@end table
-
-For example, @samp{display/i $pc} can be helpful, to see the machine
-instruction about to be executed each time execution stops (@samp{$pc}
-is a common name for the program counter; @pxref{Registers}).
-
-@table @code
-@item undisplay @var{dnums}@dots{}
-@itemx delete display @var{dnums}@dots{}
-@kindex delete display
-@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.
-(Otherwise you would just get the error @samp{No display number dots{}}.)
-
-@item disable display @var{dnums}@dots{}
-@kindex disable display
-Disable the display of item numbers @var{dnums}.  A disabled display
-item is not printed automatically, but is not forgotten.  It may be
-enabled again later.
-
-@item enable display @var{dnums}@dots{}
-@kindex enable display
-Enable display of item numbers @var{dnums}.  It becomes effective once
-again in auto display of its expression, until you specify otherwise.
-
-@item display
-Display the current values of the expressions on the list, just as is
-done when the program stops.
-
-@item info display
-@kindex info display
-Print the list of expressions previously set up to display
-automatically, each one with its item number, but without showing the
-values.  This includes disabled expressions, which are marked as such.
-It also includes expressions which would not be displayed right now
-because they refer to automatic variables not currently available.
-@end table
-
-If a display expression refers to local variables, then it does not make
-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 the 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.
-
-@node Print Settings, Value History, Auto Display, Data
-@section Print Settings
-
-@cindex format options
-@cindex print settings
-_GDBN__ provides the following ways to control how arrays, structures,
-and symbols are printed.  
-
-@noindent
-These settings are useful for debugging programs in any language:
-
-@table @code
-@item set print address
-@item set print address on
-@kindex set print address
-_GDBN__ will print 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
-@code{set print address on}:
-@smallexample
-(_GDBP__) f
-#0  set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>") 
-    at input.c:530
-530	    if (lquote != def_lquote)
-@end smallexample
-
-@item set print address off
-Do not print addresses when displaying their contents.  For example,
-this is the same stack frame displayed with @code{set print address off}:
-@example
-(_GDBP__) set print addr off
-(_GDBP__) f
-#0  set_quotes (lq="<<", rq=">>") at input.c:530
-530	    if (lquote != def_lquote)
-@end example
-
-@item show print address
-@kindex show print address
-Show whether or not addresses are to be printed.
-
-@item set print array
-@itemx set print array on
-@kindex set print array
-_GDBN__ will pretty print arrays.  This format is more convenient to read,
-but uses more space.  The default is off.
-
-@item set print array off.
-Return to compressed format for arrays.
-
-@item show print array
-@kindex show print array
-Show whether compressed or pretty format is selected for displaying
-arrays. 
-
-@item set print elements @var{number-of-elements}
-@kindex set print elements
-If _GDBN__ is printing a large array, it will stop 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.
-
-@item show print elements
-@kindex show print elements
-Display the number of elements of a large array that _GDBN__ will print
-before losing patience.
-
-@item set print pretty on
-@kindex set print pretty
-Cause _GDBN__ to print structures in an indented format with one member per
-line, like this:
-
-@example
-$1 = @{
-  next = 0x0,
-  flags = @{
-    sweet = 1,
-    sour = 1
-  @},
-  meat = 0x54 "Pork"
-@}
-@end example
-
-@item set print pretty off
-Cause _GDBN__ to print structures in a compact format, like this:
-
-@smallexample
-$1 = @{next = 0x0, flags = @{sweet = 1, sour = 1@}, meat \
-= 0x54 "Pork"@}
-@end smallexample
-
-@noindent
-This is the default format.
-
-@item show print pretty
-@kindex show print pretty
-Show which format _GDBN__ will use to print structures.
-
-@item set print sevenbit-strings on
-Print using only seven-bit characters; if this option is set, 
-_GDBN__ will display any eight-bit characters (in strings or character
-values) using the notation @code{\}@var{nnn}.  For example, @kbd{M-a} is
-displayed as @code{\341}.
-
-@item set print sevenbit-strings off
-Print using either seven-bit or eight-bit characters, as required.  This
-is the default.
-
-@item show print sevenbit-strings
-Show whether or not _GDBN__ will print only seven-bit characters.
-
-@item set print union on
-@kindex set print union
-Tell _GDBN__ to print unions which are contained in structures.  This is the
-default setting.
-
-@item set print union off
-Tell _GDBN__ not to print unions which are contained in structures.
-
-@item show print union
-@kindex show print union
-Ask _GDBN__ whether or not it will print unions which are contained in
-structures. 
-
-For example, given the declarations
-
-@smallexample
-typedef enum @{Tree, Bug@} Species;
-typedef enum @{Big_tree, Acorn, Seedling@} Tree_forms;
-typedef enum @{Caterpillar, Cocoon, Butterfly@} Bug_forms;
-
-struct thing @{
-  Species it;
-  union @{
-    Tree_forms tree;
-    Bug_forms bug;
-  @} form;
-@};
-
-struct thing foo = @{Tree, @{Acorn@}@};
-@end smallexample
-
-@noindent
-with @code{set print union on} in effect @samp{p foo} would print
-
-@smallexample
-$1 = @{it = Tree, form = @{tree = Acorn, bug = Cocoon@}@}
-@end smallexample
-
-@noindent
-and with @code{set print union off} in effect it would print
-
-@smallexample
-$1 = @{it = Tree, form = @{...@}@}
-@end smallexample
-@end table
-
-@noindent
-These settings are of interest when debugging C++ programs:
-
-@table @code
-@item set print demangle 
-@itemx set print demangle on 
-@kindex set print demangle
-Print C++ names in their source form rather than in the mangled form
-in which they are passed to the assembler and linker for type-safe linkage.
-The default is on.
-
-@item show print demangle
-@kindex show print demangle
-Show whether C++ names will be printed in mangled or demangled form.
-
-@item set print asm-demangle 
-@itemx set print asm-demangle on 
-@kindex set print asm-demangle
-Print C++ names in their source form rather than their mangled form, even
-in assembler code printouts such as instruction disassemblies.
-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
-or demangled form.
-
-@item set print object
-@itemx set print object on
-@kindex set print object
-When displaying a pointer to an object, identify the @emph{actual}
-(derived) type of the object rather than the @emph{declared} type, using
-the virtual function table.
-
-@item set print object off
-Display only the declared type of objects, without reference to the
-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.
-
-@item set print vtbl 
-@itemx set print vtbl on 
-@kindex set print vtbl
-Pretty print C++ virtual function tables.  The default is off.
-
-@item set print vtbl off
-Do not pretty print C++ virtual function tables.
-
-@item show print vtbl
-@kindex show print vtbl
-Show whether C++ virtual function tables are pretty printed, or not.
-
-@end table
-
-@node Value History, Convenience Vars, Print Settings, Data
-@section Value History
-
-@cindex value history
-Values printed by the @code{print} command are saved in _GDBN__'s @dfn{value
-history} so that you can refer to them in other expressions.  Values are
-kept until the symbol table is re-read or discarded (for example with
-the @code{file} or @code{symbol-file} commands).  When the symbol table
-changes, the value history is discarded, since the values may contain
-pointers back to the types defined in the symbol table.
-
-@cindex @code{$}
-@cindex @code{$$}
-@cindex history number
-The values printed are given @dfn{history numbers} for you to refer to them
-by.  These are successive integers starting with one.  @code{print} shows you
-the history number assigned to a value by printing @samp{$@var{num} = }
-before the value; here @var{num} is the history number.
-
-To refer to any previous value, use @samp{$} followed by the value's
-history number.  The way @code{print} labels its output is designed to
-remind you of this.  Just @code{$} refers to the most recent value in
-the history, and @code{$$} refers to the value before that.
-@code{$$@var{n}} refers to the @var{n}th value from the end; @code{$$2}
-is the value just prior to @code{$$}, @code{$$1} is equivalent to
-@code{$$}, and @code{$$0} is equivalent to @code{$}.
-
-For example, suppose you have just printed a pointer to a structure and
-want to see the contents of the structure.  It suffices to type
-
-@example
-p *$
-@end example
-
-If you have a chain of structures where the component @code{next} points
-to the next one, you can print the contents of the next one with this:
-
-@example
-p *$.next
-@end example
-
-@noindent
-You can print successive links in the chain by repeating this
-command---which you can do by just typing @key{RET}.
-
-Note that the history records values, not expressions.  If the value of
-@code{x} is 4 and you type these commands:
-
-@example
-print x
-set x=5
-@end example
-
-@noindent
-then the value recorded in the value history by the @code{print} command
-remains 4 even though the value of @code{x} has changed.
-
-@table @code
-@kindex show values
-@item show values
-Print the last ten values in the value history, with their item numbers.
-This is like @samp{p@ $$9} repeated ten times, except that @code{show
-values} does not change the history.
-
-@item show values @var{n}
-Print ten history values centered on history item number @var{n}.
-
-@item show values +
-Print ten history values just after the values last printed.  If no more
-values are available, produces no display.
-@end table
-
-Pressing @key{RET} to repeat @code{show values @var{n}} has exactly the
-same effect as @samp{show values +}.  
-
-@node Convenience Vars, Registers, Value History, Data
-@section Convenience Variables
-
-@cindex convenience variables
-_GDBN__ provides @dfn{convenience variables} that you can use within
-_GDBN__ to hold on to a value and refer to it later.  These variables
-exist entirely within _GDBN__; they are not part of your program, and
-setting a convenience variable has no direct effect on further execution
-of your program.  That's why you can use them freely.
-
-Convenience variables are prefixed with @samp{$}.  Any name preceded by
-@samp{$} can be used for a convenience variable, unless it is one of
-the predefined machine-specific register names (@pxref{Registers}).
-(Value history references, in contrast, are @emph{numbers} preceded
-by @samp{$}.  @xref{Value History}.)
-
-You can save a value in a convenience variable with an assignment
-expression, just as you would set a variable in your program.  Example:
-
-@example
-set $foo = *object_ptr
-@end example
-
-@noindent
-would save in @code{$foo} the value contained in the object pointed to by
-@code{object_ptr}.
-
-Using a convenience variable for the first time creates it; but its value
-is @code{void} until you assign a new value.  You can alter the value with
-another assignment at any time.
-
-Convenience variables have no fixed types.  You can assign a convenience
-variable any type of value, including structures and arrays, even if
-that variable already has a value of a different type.  The convenience
-variable, when used as an expression, has the type of its current value.
-
-@table @code
-@item show convenience
-@kindex show convenience
-Print a list of convenience variables used so far, and their values.
-Abbreviated @code{show con}.
-@end table
-
-One of the ways to use a convenience variable is as a counter to be
-incremented or a pointer to be advanced.  For example, to print
-a field from successive elements of an array of structures:
-
-_0__@example
-set $i = 0
-print bar[$i++]->contents
-@i{@dots{} repeat that command by typing @key{RET}.}
-_1__@end example
-
-Some convenience variables are created automatically by _GDBN__ and given
-values likely to be useful.
-
-@table @code
-@item $_
-The variable @code{$_} is automatically set by the @code{x} command to
-the last address examined (@pxref{Memory}).  Other commands which
-provide a default address for @code{x} to examine also set @code{$_}
-to that address; these commands include @code{info line} and @code{info
-breakpoint}.
-
-@item $__
-The variable @code{$__} is automatically set by the @code{x} command
-to the value found in the last address examined.
-@end table
-
-@node Registers, Floating Point Hardware, Convenience Vars, Data
-@section Registers
-
-@cindex registers
-Machine register contents can be referred to in expressions as variables
-with names starting with @samp{$}.  The names of registers are different
-for each machine; use @code{info registers} to see the names used on
-your machine.  
-
-@table @code
-@item info registers
-@kindex info registers
-Print the names and values of all registers (in the selected stack frame).
-
-@item info registers @var{regname}
-Print the relativized value of register @var{regname}.  @var{regname}
-may be any register name valid on the machine you are using, with
-or without the initial @samp{$}.
-@end table
-
-The register names @code{$pc} and @code{$sp} are used on most machines
-for the program counter register and the stack pointer.  For example,
-you could print the program counter in hex with
-@example
-p/x $pc
-@end example
-
-@noindent
-or print the instruction to be executed next with
-@example
-x/i $pc
-@end example
-
-@noindent
-or add four to the stack pointer with
-@example
-set $sp += 4
-@end example
-
-@noindent
-The last is a way of removing one word from the stack, on machines where
-stacks grow downward in memory (most machines, nowadays).  This assumes
-that the innermost stack frame is selected; setting @code{$sp} is
-not allowed when other stack frames are selected.  (To pop entire frames
-off the stack, regardless of machine architecture, use @code{return};
-@pxref{Returning}.)
-
-Often @code{$fp} is used for a register that contains a pointer to the
-current stack frame, and @code{$ps} is sometimes used for a register
-that contains the processor status.  These standard register names may
-be available on your machine even though the @code{info registers}
-command shows other names.  For example, on the SPARC, @code{info
-registers} displays the processor status register as @code{$psr} but you
-can also refer to it as @code{$ps}.
-
-_GDBN__ always considers the contents of an ordinary register as an
-integer when the register is examined in this way.  Some machines have
-special registers which can hold nothing but floating point; these
-registers are considered to have floating point values.  There is no way
-to refer to the contents of an ordinary register as floating point value
-(although you can @emph{print} it as a floating point value with
-@samp{print/f $@var{regname}}).
-
-Some registers have distinct ``raw'' and ``virtual'' data formats.  This
-means that the data format in which the register contents are saved by
-the operating system is not the same one that your program normally
-sees.  For example, the registers of the 68881 floating point
-coprocessor are always saved in ``extended'' (raw) format, but all C
-programs expect to work with ``double'' (virtual) format.  In such
-cases, _GDBN__ normally works with the virtual format only (the format that
-makes sense for your program), but the @code{info registers} command
-prints the data in both formats.
-
-Normally, register values are relative to the selected stack frame
-(@pxref{Selection}).  This means that you get the value that the
-register would contain if all stack frames farther in were exited and
-their saved registers restored.  In order to see the true contents of
-hardware registers, you must select the innermost frame (with
-@samp{frame 0}).
-
-However, _GDBN__ must deduce where registers are saved, from the machine
-code generated by your compiler.  If some registers are not saved, or if
-_GDBN__ is unable to locate the saved registers, the selected stack
-frame will make no difference.
-
-@node Floating Point Hardware,  , Registers, Data
-@section Floating Point Hardware
-@cindex floating point
-Depending on the host machine architecture, _GDBN__ may be able to give
-you more information about the status of the floating point hardware.
-
-@table @code
-@item info float
-@kindex info float
-If available, provides hardware-dependent information about the floating
-point unit.  The exact contents and layout vary depending on the
-floating point chip.
-@end table
-@c FIXME: this is a cop-out.  Try to get examples, explanations.  Only
-@c FIXME...supported currently on arm's and 386's.  Mark properly with 
-@c FIXME... m4 macros to isolate general statements from hardware-dep, 
-@c FIXME... at that point.
-
-@node Symbols, Altering, Data, Top
-@chapter Examining the Symbol Table
-
-The commands described in this section allow you to inquire about the
-symbols (names of variables, functions and types) defined in your
-program.  This information is inherent in the text of your program and
-does not change as the program executes.  _GDBN__ finds it in your
-program's symbol table, in the file indicated when you started _GDBN__ 
-(@pxref{File Options}), or by one of the file-management commands
-(@pxref{Files}).
-
-@table @code
-@item info address @var{symbol}
-@kindex info address
-Describe where the data for @var{symbol} is stored.  For a register
-variable, this says which register it is kept in.  For a non-register
-local variable, this prints the stack-frame offset at which the variable
-is always stored.
-
-Note the contrast with @samp{print &@var{symbol}}, which does not work
-at all for a register variables, and for a stack local variable prints
-the exact address of the current instantiation of the variable.
-
-@item whatis @var{exp}
-@kindex whatis
-Print the data type of expression @var{exp}.  @var{exp} is not
-actually evaluated, and any side-effecting operations (such as
-assignments or function calls) inside it do not take place.
-@xref{Expressions}.
-
-@item whatis
-Print the data type of @code{$}, the last value in the value history.
-
-@item ptype @var{typename}
-@kindex ptype
-Print a description of data type @var{typename}.  @var{typename} may be
-the name of a type, or for C code it may have the form
-@samp{struct @var{struct-tag}}, @samp{union @var{union-tag}} or
-@samp{enum @var{enum-tag}}.@refill
-
-@item ptype @var{exp}
-Print a description of the type of expression @var{exp}.  @code{ptype}
-differs from @code{whatis} by printing a detailed description, instead of just
-the name of the type.  For example, if your program declares a variable
-as
-@example
-struct complex {double real; double imag;} v;
-@end example
-@noindent
-compare the output of the two commands:
-@example
-(_GDBP__) whatis v
-type = struct complex
-(_GDBP__) ptype v
-type = struct complex {
-    double real;
-    double imag;
-}
-@end example
-
-@item info types @var{regexp}
-@itemx info types
-@kindex info types 
-Print a brief description of all types whose name matches @var{regexp}
-(or all types in your program, if you supply no argument).  Each
-complete typename is matched as though it were a complete line; thus,
-@samp{i type value} gives information on all types in your program whose
-name includes the string @code{value}, but @samp{i type ^value$} gives
-information only on types whose complete name is @code{value}.
-
-This command differs from @code{ptype} in two ways: first, like
-@code{whatis}, it does not print a detailed description; second, it
-lists all source files where a type is defined.
-
-@item info source
-@kindex info source
-Show the name of the current source file---that is, the source file for
-the function containing the current point of execution.
-
-@item info sources
-@kindex info sources
-Print the names of all source files in the program for which there is
-debugging information, organized into two lists: those for which symbols
-have been read in, and those for which symbols will be read in on
-demand.
-@c FIXME: above passive AND awkward!
-
-@item info functions
-@kindex info functions
-Print the names and data types of all defined functions.
-
-@item info functions @var{regexp}
-Print the names and data types of all defined functions
-whose names contain a match for regular expression @var{regexp}.
-Thus, @samp{info fun step} finds all functions whose names
-include @code{step}; @samp{info fun ^step} finds those whose names
-start with @code{step}.
-
-@item info variables
-@kindex info variables
-Print the names and data types of all variables that are declared
-outside of functions (i.e., excluding local variables).
-
-@item info variables @var{regexp}
-Print the names and data types of all variables (except for local
-variables) whose names contain a match for regular expression
-@var{regexp}.
-
-
-@ignore
-This was never implemented.
-@item info methods
-@itemx info methods @var{regexp}
-@kindex info methods
-The @code{info methods} command permits the user to examine all defined
-methods within C++ program, or (with the @var{regexp} argument) a
-specific set of methods found in the various C++ classes.  Many
-C++ classes provide a large number of methods.  Thus, the output
-from the @code{ptype} command can be overwhelming and hard to use.  The
-@code{info-methods} command filters the methods, printing only those
-which match the regular-expression @var{regexp}.
-@end ignore
-
-@item printsyms @var{filename}
-@kindex printsyms
-Write a complete dump of the debugger's symbol data into the
-file @var{filename}.
-@end table
-
-@node Altering, _GDBN__ Files, Symbols, Top
-@chapter Altering Execution
-
-Once you think you have found an error in the program, you might want to
-find out for certain whether correcting the apparent error would lead to
-correct results in the rest of the run.  You can find the answer by
-experiment, using the _GDBN__ features for altering execution of the
-program.
-
-For example, you can store new values into variables or memory
-locations, give the program a signal, restart it at a different address,
-or even return prematurely from a function to its caller.
-
-@menu
-* Assignment::			Assignment to Variables
-* Jumping::			Continuing at a Different Address
-* Signaling::			Giving the Program a Signal
-* Returning::			Returning from a Function
-* Calling::			Calling your Program's Functions
-@end menu
-
-@node Assignment, Jumping, Altering, Altering
-@section Assignment to Variables
-
-@cindex assignment
-@cindex setting variables
-To alter the value of a variable, evaluate an assignment expression.
-@xref{Expressions}.  For example,
-
-@example
-print x=4
-@end example
-
-@noindent
-would store the value 4 into the variable @code{x}, and then print the
-value of the assignment expression (which is 4).  All the assignment
-operators of C are supported, including the increment operators
-@samp{++} and @samp{--}, and combining assignments such as @samp{+=} and
-_0__@samp{<<=}_1__.
-
-@kindex set
-@kindex set variable
-@cindex variables, setting
-If you are not interested in seeing the value of the assignment, use the
-@code{set} command instead of the @code{print} command.  @code{set} is
-really the same as @code{print} except that the expression's value is not
-printed and is not put in the value history (@pxref{Value History}).  The
-expression is evaluated only for its effects.
-
-If the beginning of the argument string of the @code{set} command
-appears identical to a @code{set} subcommand, use the @code{set
-variable} command instead of just @code{set}.  This command is identical
-to @code{set} except for its lack of subcommands.  For example, a
-program might well have a variable @code{width}---which leads to
-an error if we try to set a new value with just @samp{set width=13}, as
-we might if @code{set width} didn't happen to be a _GDBN__ command:
-@example
-(_GDBP__) whatis width
-type = double
-(_GDBP__) p width
-$4 = 13
-(_GDBP__) set width=47
-Invalid syntax in expression.
-@end example
-@noindent
-The invalid expression, of course, is @samp{=47}.  What we can do in
-order to actually set our program's variable @code{width} is 
-@example
-(_GDBP__) set var width=47
-@end example
-
-_GDBN__ allows more implicit conversions in assignments than C does; you can
-freely store an integer value into a pointer variable or vice versa, and
-any structure can be converted to any other structure that is the same
-length or shorter.
-@comment FIXME: how do structs align/pad in these conversions? 
-@comment        /pesch@cygnus.com 18dec1990
-
-To store values into arbitrary places in memory, use the @samp{@{@dots{}@}}
-construct to generate a value of specified type at a specified address
-(@pxref{Expressions}).  For example, @code{@{int@}0x83040} refers
-to memory location @code{0x83040} as an integer (which implies a certain size
-and representation in memory), and
-
-@example
-set @{int@}0x83040 = 4
-@end example
-
-@noindent
-stores the value 4 into that memory location.
-
-@node Jumping, Signaling, Assignment, Altering
-@section Continuing at a Different Address
-
-Ordinarily, when you continue the program, you do so at the place where
-it stopped, with the @code{continue} command.  You can instead continue at
-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
-immediately if there is a breakpoint there.  @xref{List} for a
-description of the different forms of @var{linespec}.
-
-The @code{jump} command does not change the current stack frame, or
-the stack pointer, or the contents of any memory location or any
-register other than the program counter.  If line @var{linespec} is in
-a different function from the one currently executing, the results may
-be bizarre if the two functions expect different patterns of arguments or
-of local variables.  For this reason, the @code{jump} command requests
-confirmation if the specified line is not in the function currently
-executing.  However, even bizarre results are predictable if you are
-well acquainted with the machine-language code of the program.
-
-@item jump *@var{address}
-Resume execution at the instruction at address @var{address}.
-@end table
-
-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 the program running; it only changes the address where it
-@emph{will} run when it is continued.  For example,
-
-@example
-set $pc = 0x485
-@end example
-
-@noindent
-causes the next @code{continue} command or stepping command to execute at
-address 0x485, rather than at the address where the program stopped.
-@xref{Stepping}.
-
-The most common occasion to use the @code{jump} command is to back up,
-perhaps with more breakpoints set, over a portion of a program that has
-already executed, in order to examine its execution in more detail.
-
-@group
-@node Signaling, Returning, Jumping, Altering
-@section Giving the Program a Signal
-
-@table @code
-@item signal @var{signalnum}
-@kindex signal
-Resume execution where the program stopped, but give it immediately the
-signal number @var{signalnum}.
-
-Alternatively, if @var{signalnum} is zero, continue execution without
-giving a signal.  This is useful when the program stopped on account of
-a signal and would ordinary see the signal when resumed with the
-@code{continue} command; @samp{signal 0} causes it to resume without a
-signal.
-
-@code{signal} does not repeat when you press @key{RET} a second time
-after executing the command.
-@end table
-@end group
-
-@node Returning, Calling, Signaling, Altering
-@section Returning from a Function
-
-@table @code
-@item return
-@itemx return @var{expression}
-@cindex returning from a function
-@kindex return
-You can cancel execution of a function call with the @code{return}
-command.  If you give an
-@var{expression} argument, its value is used as the function's return
-value. 
-@end table
-
-When you use @code{return}, _GDBN__ discards the selected stack frame
-(and all frames within it).  You can think of this as making the
-discarded frame return prematurely.  If you wish to specify a value to
-be returned, give that value as the argument to @code{return}.
-
-This pops the selected stack frame (@pxref{Selection}), and any other
-frames inside of it, leaving its caller as the innermost remaining
-frame.  That frame becomes selected.  The specified value is stored in
-the registers used for returning values of functions.
-
-The @code{return} command does not resume execution; it leaves the
-program stopped in the state that would exist if the function had just
-returned.  In contrast, the @code{finish} command (@pxref{Stepping})
-resumes execution until the selected stack frame returns naturally.
-
-@node     Calling,  , Returning, Altering
-@section Calling your Program's Functions
-
-@cindex calling functions
-@kindex call
-@table @code
-@item call @var{expr}
-Evaluate the expression @var{expr} without displaying @code{void}
-returned values.
-@end table
-
-You can use this variant of the @code{print} command if you want to
-execute a function from your program, but without cluttering the output
-with @code{void} returned values.  The result is printed and saved in
-the value history, if it is not void.
-
-@node _GDBN__ Files, Targets, Altering, Top
-@chapter _GDBN__'s Files
-
-@menu
-* Files::			Commands to Specify Files
-* Symbol Errors::		Errors Reading Symbol Files
-@end menu
-
-@node Files, Symbol Errors, _GDBN__ Files, _GDBN__ Files
-@section Commands to Specify Files
-@cindex core dump file
-@cindex symbol table
-_GDBN__ needs to know the file name of the program to be debugged, both in
-order to read its symbol table and in order to start the program.  To
-debug a core dump of a previous run, _GDBN__ must be told the file name of
-the core dump.
-
-The usual way to specify the executable and core dump file names is with
-the command arguments given when you start _GDBN__, as discussed in
-@pxref{Invocation}.
-
-Occasionally it is necessary to change to a different file during a
-_GDBN__ session.  Or you may run _GDBN__ and forget to specify the files you
-want to use.  In these situations the _GDBN__ commands to specify new files
-are useful.
-
-@table @code
-@item file @var{filename}
-@cindex executable file
-@kindex file
-Use @var{filename} as the program to be debugged.  It is read for its
-symbols and for the contents of pure memory.  It is also the program
-executed when you use the @code{run} command.  If you do not specify a
-directory and the file is not found in _GDBN__'s working directory,
-
-_GDBN__ uses the environment variable @code{PATH} as a list of
-directories to search, just as the shell does when looking for a program
-to run.  You can change the value of this variable, for both _GDBN__ and
-your program, using the @code{path} command.
-
-@code{file} with no argument makes _GDBN__ discard any information it
-has on both executable file and the symbol table.
-
-@item exec-file @var{filename}
-@kindex exec-file
-Specify that the program to be run (but not the symbol table) is found
-in @var{filename}.  _GDBN__ will search the environment variable @code{PATH}
-if necessary to locate the program.  
-
-@item symbol-file @var{filename}
-@kindex symbol-file
-Read symbol table information from file @var{filename}.  @code{PATH} is
-searched when necessary.  Use the @code{file} command to get both symbol
-table and program to run from the same file.
-
-@code{symbol-file} with no argument clears out _GDBN__'s information on your
-program's symbol table.
-
-The @code{symbol-file} command causes _GDBN__ to forget the contents of its
-convenience variables, the value history, and all breakpoints and
-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 _GDBN__.
-
-@code{symbol-file} will not repeat if you press @key{RET} again after
-executing it once.
-
-On some kinds of object files, the @code{symbol-file} command does not
-actually read the symbol table in full right away.  Instead, it scans
-the symbol table quickly to find which source files and which symbols
-are present.  The details are read later, one source file at a time,
-when they are needed.
-
-The purpose of this two-stage reading strategy is to make _GDBN__ start up
-faster.  For the most part, it is invisible except for occasional pauses
-while the symbol table details for a particular source file are being
-read.  (The @code{set verbose} command can turn these pauses into
-messages if desired. @xref{Messages/Warnings}).
-
-When the symbol table is stored in COFF format, @code{symbol-file} does
-read the symbol table data in full right away.  We haven't implemented
-the two-stage strategy for COFF yet.
-
-When _GDBN__ is configured for a particular environment, it will
-understand 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{_GCC__}
-you can generate debugging information for optimized code.
-
-@item core-file @var{filename}
-@itemx core @var{filename}
-@kindex core
-@kindex core-file
-Specify the whereabouts of a core dump file to be used as the ``contents
-of memory''.  Traditionally, core files contain only some parts of the
-address space of the process that generated them; _GDBN__ can access the
-executable file itself for other parts.
-
-@code{core-file} with no argument specifies that no core file is
-to be used.
-
-Note that the core file is ignored when your program is actually running
-under _GDBN__.  So, if you have been running the program and you wish to
-debug a core file instead, you must kill the subprocess in which the
-program is running.  To do this, use the @code{kill} command
-(@pxref{Kill Process}).
-
-@item load @var{filename}
-@kindex load
-_if__(_GENERIC__)
-Depending on what remote debugging facilities are configured into
-_GDBN__, the @code{load} command may be available.  Where it exists, it
-is meant to make @var{filename} (an executable) available for debugging
-on the remote system---by downloading, or dynamic linking, for example.
-@code{load} also records @var{filename}'s symbol table in _GDBN__, like
-the @code{add-symbol-file} command.
-
-If @code{load} is not available on your _GDBN__, attempting to execute
-it gets the error message ``@code{You can't do that when your target is
-@dots{}}'' 
-_fi__(_GENERIC__)
-
-_if__(_VXWORKS__) 
-On VxWorks, @code{load} will dynamically link @var{filename} on the
-current target system as well as adding its symbols in _GDBN__.
-_fi__(_VXWORKS__)
-
-_if__(_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
-_GDBN__. 
-_fi__(_I960__)
-
-@code{load} will not repeat if you press @key{RET} again after using it.
-
-@item add-symbol-file @var{filename} @var{address}
-@kindex add-symbol-file
-@cindex dynamic linking
-The @code{add-symbol-file} command reads additional symbol table information
-from the file @var{filename}.  You would use this command when that file
-has been dynamically loaded (by some other means) into the program that
-is running.  @var{address} should be the memory address at which the
-file has been loaded; _GDBN__ cannot figure this out for itself.
-
-The symbol table of the file @var{filename} is added to the symbol table
-originally read with the @code{symbol-file} command.  You can use the
-@code{add-symbol-file} command any number of times; the new symbol data thus
-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.
-
-@item info files
-@itemx info target
-@kindex info files
-@kindex info target
-@code{info files} and @code{info target} are synonymous; both print the
-current targets (@pxref{Targets}), including the names of the executable
-and core dump files currently in use by _GDBN__, and the files from
-which symbols were loaded.  The command @code{help targets} lists all
-possible targets rather than current ones.
-
-@end table
-
-All file-specifying commands allow both absolute and relative file names
-as arguments.  _GDBN__ always converts the file name to an absolute path
-name and remembers it that way.
-
-@kindex sharedlibrary
-@kindex share
-@cindex shared libraries
-
-_GDBN__ supports the SunOS shared library format.  Symbols from a shared
-library cannot be referenced before the shared library has been linked
-with the program.  (That is to say, until after you type @code{run} and 
-the function @code{main} has been entered; or when examining core
-files.)  Once the shared library has been linked in, you can use the
-following commands:
-
-@table @code
-@item sharedlibrary @var{regex}
-@itemx share @var{regex}
-Load shared object library symbols for files matching a UNIX regular
-expression.  
-
-@item share
-@itemx sharedlibrary
-Load symbols for all shared libraries.
-
-@item info share
-@itemx info sharedlibrary
-@kindex info sharedlibrary
-@kindex info share
-Print the names of the shared libraries which you have loaded with the
-@code{sharedlibrary} command.
-@end table
-
-@code{sharedlibrary} does not repeat automatically when you press
-@key{RET} after using it once.
-
-@node Symbol Errors,  , Files, _GDBN__ Files
-@section Errors Reading Symbol Files
-While a symbol file is being read, _GDBN__ will occasionally encounter
-problems, such as symbol types it does not recognize, or known bugs in
-compiler output.  By default, it prints one message about each such
-type of problem, no matter how many times the problem occurs.  You can
-ask it to print more messages, to see how many times the problems occur,
-or can shut the messages off entirely, with the @code{set 
-complaints} command (@xref{Messages/Warnings}).
-
-The messages currently printed, and their meanings, are:
-
-@table @code
-@item inner block not inside outer block in @var{symbol}
-
-The symbol information shows where symbol scopes begin and end
-(such as at the start of a function or a block of statements).  This
-error indicates that an inner scope block is not fully contained
-in its outer scope blocks.  
-
-_GDBN__ circumvents the problem by treating the inner block as if it had
-the same scope as the outer block.  In the error message, @var{symbol}
-may be shown as ``@code{(don't know)}'' if the outer block is not a
-function.
-
-@item block at @var{address} out of order
-
-The symbol information for symbol scope blocks should occur in 
-order of increasing addresses.  This error indicates that it does not
-do so.  
-
-_GDBN__ does not circumvent this problem, and will have trouble locating
-symbols in the source file whose symbols being read.  (You can often
-determine what source file is affected by specifying @code{set verbose
-on}.  @xref{Messages/Warnings}.)
-
-@item bad block start address patched
-
-The symbol information for a symbol scope block has a start address
-smaller than the address of the preceding source line.  This is known
-to occur in the SunOS 4.1.1 (and earlier) C compiler.  
-
-_GDBN__ circumvents the problem by treating the symbol scope block as
-starting on the previous source line.
-
-@c @item{encountered DBX-style class variable debugging information.
-@c You seem to have compiled your program with "g++ -g0" instead of "g++ -g".
-@c Therefore _GDBN__ will not know about your class variables}
-@c 
-@c This error indicates that the symbol information produced for a C++
-@c program includes zero-size fields, which indicated static fields in
-@c a previous release of the G++ compiler.  This message is probably
-@c obsolete.
-@c
-@item bad string table offset in symbol @var{n}
-
-@cindex foo
-Symbol number @var{n} contains a pointer into the string table which is
-larger than the size of the string table.  
-
-_GDBN__ circumvents the problem by considering the symbol to have the
-name @code{foo}, which may cause other problems if many symbols end up
-with this name.
-
-@item unknown symbol type @code{0x@var{nn}}
-
-The symbol information contains new data types that _GDBN__ does not yet
-know how to read.  @code{0x@var{nn}} is the symbol type of the misunderstood
-information, in hexadecimal.  
-
-_GDBN__ circumvents the error by ignoring this symbol information.  This
-will usually allow the program to be debugged, though certain symbols
-will not be accessible.  If you encounter such a problem and feel like
-debugging it, you can debug @code{_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.
-
-@item stub type has NULL name
-_GDBN__ could not find the full definition for a struct or class. 
-
-@ignore
-@c this is #if 0'd in dbxread.c as of (at least!) 17 may 1991
-@item const/volatile indicator missing, got '@var{X}'
-
-The symbol information for a C++ member function is missing some
-information that the compiler should have output for it.
-@end ignore
-
-@item C++ type mismatch between compiler and debugger
-
-The debugger could not parse a type specification output by the compiler
-for some C++ object.
-
-@end table
-
-@node     Targets, Controlling _GDBN__, _GDBN__ Files, Top
-@chapter Specifying a Debugging Target 
-@cindex debugging target
-@kindex target
-A @dfn{target} is an interface between the debugger and a particular 
-kind of file or process.  
-
-Often, you will be able to run _GDBN__ in the same host environment as the
-program you are debugging; in that case, the debugging target can just be
-specified as a side effect of the @code{file} or @code{core} commands.
-When you need more flexibility---for example, running _GDBN__ on a
-physically separate host, controlling standalone systems over a
-serial port, or realtime systems over a TCP/IP connection---you can use
-the @code{target} command.
-
-@menu
-* Active Targets::		Active Targets
-* Target Commands::		Commands for Managing Targets
-* Remote::			Remote Debugging
-@end menu
-
-@node Active Targets, Target Commands, Targets, Targets
-@section Active Targets
-@cindex stacking targets
-@cindex active targets
-@cindex multiple targets
-
-Targets are managed in three @dfn{strata} that correspond to different
-classes of target: processes, core files, and executable files.  This
-allows you to (for example) start a process and inspect its activity
-without abandoning your work on a core file.
-
-More than one target can potentially respond to a request.  In
-particular, when you access memory _GDBN__ will examine the three strata of
-targets until it finds a target that can handle that particular address.
-Strata are always examined in a fixed order: first a process if there is
-one, then a core file if there is one, and finally an executable file if
-there is one of those.
-
-When you specify a new target in a given stratum, it replaces any target
-previously in that stratum.
-
-To get rid of a target without replacing it, use the @code{detach}
-command.  The related command @code{attach} provides you with a way of
-choosing a particular running process as a new target. @xref{Attach}.
-
-@node Target Commands, Remote, Active Targets, Targets
-@section Commands for Managing Targets
-
-@table @code
-@item target @var{type} @var{parameters}
-Connects the _GDBN__ host environment to a target machine or process.  A
-target is typically a protocol for talking to debugging facilities.  You
-use the argument @var{type} to specify the type or protocol of the
-target machine.
-
-Further @var{parameters} are interpreted by the target protocol, but
-typically include things like device names or host names to connect
-with, process numbers, and baud rates.  
-
-The @code{target} command will not repeat if you press @key{RET} again
-after executing the command.
-
-@item help target
-@kindex help target
-Displays the names of all targets available.  To display targets
-currently selected, use either @code{info target} or @code{info files}
-(@pxref{Files}).
-
-@item help target @var{name}
-Describe a particular target, including any parameters necessary to
-select it.
-@end table
-
-Here are some common targets (available, or not, depending on the _GDBN__
-configuration):
-
-@table @code
-@item target exec @var{prog}
-@kindex target exec
-An executable file.  @samp{target exec @var{prog}} is the same as
-@samp{exec-file @var{prog}}.
-
-@item target core @var{filename}
-@kindex target core
-A core dump file.  @samp{target core @var{filename}} is the same as
-@samp{core-file @var{filename}}.
-
-@item target remote @var{dev}
-@kindex target remote
-Remote serial target in _GDBN__-specific protocol.  The argument @var{dev}
-specifies what serial device to use for the connection (e.g.
-@file{/dev/ttya}). @xref{Remote}.
-
-_if__(_AMD29K__)
-@item target amd-eb @var{dev} @var{speed} @var{PROG}
-@kindex target amd-eb
-@cindex AMD EB29K
-Remote PC-resident AMD EB29K board, attached over serial lines.
-@var{dev} is the serial device, as for @code{target remote};
-@var{speed} allows you to specify the linespeed; and @var{PROG} is the
-name of the program to be debugged, as it appears to DOS on the PC.
-@xref{EB29K Remote}.
-
-_fi__(_AMD29K__)
-_if__(_I960__)
-@item target nindy @var{devicename}
-@kindex target nindy
-An Intel 960 board controlled by a Nindy Monitor.  @var{devicename} is
-the name of the serial device to use for the connection, e.g.
-@file{/dev/ttya}.  @xref{i960-Nindy Remote}.
-
-_fi__(_I960__)
-_if__(_VXWORKS__)
-@item target vxworks @var{machinename}
-@kindex target vxworks
-A VxWorks system, attached via TCP/IP.  The argument @var{machinename}
-is the target system's machine name or IP address.
-@xref{VxWorks Remote}.
-_fi__(_VXWORKS__)
-@end table
-
-_if__(_GENERIC__)
-Different targets are available on different configurations of _GDBN__; your
-configuration may have more or fewer targets.
-_fi__(_GENERIC__)
-
-@node Remote,  , Target Commands, Targets
-@section Remote Debugging
-@cindex remote debugging
-
-_if__(_GENERIC__)
-@menu
-_undivert__(1)
-@end menu
-_fi__(_GENERIC__)
-
-If you are trying to debug a program running on a machine that can't run
-_GDBN__ in the usual way, it is often useful to use remote debugging.  For
-example, you might use remote debugging on an operating system kernel, or on
-a small system which does not have a general purpose operating system
-powerful enough to run a full-featured debugger.  
-
-Some configurations of _GDBN__ have special serial or TCP/IP interfaces
-to make this work with particular debugging targets.  In addition,
-_GDBN__ comes with a generic serial protocol (specific to _GDBN__, 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
-communicate with _GDBN__.
-
-To use the _GDBN__ remote serial protocol, the program to be debugged on
-the remote machine needs to contain a debugging stub which talks to
-_GDBN__ over the serial line.  Several working remote stubs are
-distributed with _GDBN__; see the @file{README} file in the _GDBN__
-distribution for more information.
-
-For details of this communication protocol, see the comments in the
-_GDBN__ source file @file{remote.c}.
-
-To start remote debugging, first run _GDBN__ and specify as an executable file
-the program that is running in the remote machine.  This tells _GDBN__ how
-to find the program's symbols and the contents of its pure text.  Then
-establish communication using the @code{target remote} command with a device
-name as an argument.  For example:
-
-@example
-target remote /dev/ttyb
-@end example
-
-@noindent
-if the serial line is connected to the device named @file{/dev/ttyb}.  This
-will stop the remote machine if it is not already stopped.
-
-Now you can use all the usual commands to examine and change data and to
-step and continue the remote program.
-
-To resume the remote program and stop debugging it, use the @code{detach}
-command.
-
-Other remote targets may be available in your
-configuration of _GDBN__; use @code{help targets} to list them.  
-
-_if__(_GENERIC__)
-_undivert__(2)
-@c Text on starting up GDB in various specific cases; it goes up front
-@c in manuals configured for any of those particular situations, here
-@c otherwise. 
-_fi__(_GENERIC__)
-
-@node Controlling _GDBN__, Sequences, Targets, Top
-@chapter Controlling _GDBN__
-
-You can alter many aspects of _GDBN__'s interaction with you by using
-the @code{set} command.  For commands controlling how _GDBN__ displays
-data, @pxref{Print Settings}; other settings are described here.
-
-@menu
-* Prompt::			Prompt
-* Editing::			Command Editing
-* History::			Command History
-* Screen Size::			Screen Size
-* Numbers::			Numbers
-* Messages/Warnings::		Optional Warnings and Messages
-@end menu
-
-@node Prompt, Editing, Controlling _GDBN__, Controlling _GDBN__
-@section Prompt
-@cindex prompt
-_GDBN__ indicates its readiness to read a command by printing a string
-called the @dfn{prompt}.  This string is normally @samp{(_GDBP__)}.  You
-can change the prompt string with the @code{set prompt} command.  For
-instance, when debugging _GDBN__ with _GDBN__, it is useful to change
-the prompt in one of the _GDBN__<>s so that you can always tell which
-one you are talking to.
-
-@table @code
-@item set prompt @var{newprompt}
-@kindex set prompt
-Directs _GDBN__ to use @var{newprompt} as its prompt string henceforth.
-@kindex show prompt
-@item show prompt
-Prints a line of the form: @samp{Gdb's prompt is: @var{your-prompt}}
-@end table
-
-@node Editing, History, Prompt, Controlling _GDBN__
-@section Command Editing
-@cindex readline
-@cindex command line editing
-_GDBN__ reads its input commands via the @dfn{readline} interface.  This
-GNU library provides consistent behavior for programs which provide a
-command line interface to the user.  Advantages are @code{emacs}-style
-or @code{vi}-style inline editing of commands, @code{csh}-like history
-substitution, and a storage and recall of command history across
-debugging sessions.
-
-You may control the behavior of command line editing in _GDBN__ with the
-command @code{set}.  
-
-@table @code
-@kindex set editing
-@cindex editing
-@item set editing
-@itemx set editing on
-Enable command line editing (enabled by default).
-
-@item set editing off
-Disable command line editing.
-
-@kindex show editing
-@item show editing
-Show whether command line editing is enabled.
-
-@node History, Screen Size, Editing, Controlling _GDBN__
-@section Command History
-@cindex history substitution
-@cindex history file
-@kindex set history filename
-@item set history filename @var{fname}
-Set the name of the _GDBN__ command history file to @var{fname}.  This is
-the file from which _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
-@file{./.gdb_history} if this variable is not set.
-
-@cindex history save
-@kindex set history save
-@item set history save
-@itemx set history save on
-Record command history in a file, whose name may be specified with the
-@code{set history filename} command.  By default, this option is disabled.
-
-@item set history save off
-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 _GDBN__ will keep 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
-
-@cindex history expansion
-History expansion assigns special meaning to the character @kbd{!}.
-@iftex
-(@xref{Event Designators}.)
-@end iftex
-Since @kbd{!} is also the logical not operator in C, history expansion
-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
-@kbd{!=} and @kbd{!(}, even when history expansion is enabled.
-
-The commands to control history expansion are:
-
-@table @code
-
-@kindex set history expansion
-@item set history expansion on
-@itemx set history expansion
-Enable history expansion.  History expansion is off by default.
-
-@item set history expansion off
-Disable history expansion.
-
-The readline code comes with more complete documentation of
-editing and history expansion features.  Users unfamiliar with @code{emacs}
-or @code{vi} may wish to read it. 
-@iftex
-@xref{Command Line Editing}.
-@end iftex
-
-@group
-@kindex show history
-@item show history
-@itemx show history filename
-@itemx show history save
-@itemx show history size
-@itemx show history expansion
-These commands display the state of the _GDBN__ history parameters.
-@code{show history} by itself displays all four states.
-@end group
-
-@end table
-
-@table @code
-@kindex show commands
-@item show commands
-Display the last ten commands in the command history.
-
-@item show commands @var{n}
-Print ten commands centered on command number @var{n}.
-
-@item show commands +
-Print ten commands just after the commands last printed.
-
-@end table
-
-@node Screen Size, Numbers, History, Controlling _GDBN__
-@section Screen Size
-@cindex size of screen
-@cindex pauses in output
-Certain commands to _GDBN__ may produce large amounts of information
-output to the screen.  To help you read all of it, _GDBN__ pauses and
-asks you for input at the end of each page of output.  Type @key{RET}
-when you want to continue the output.  _GDBN__ also uses the screen
-width setting to determine when to wrap lines of output.  Depending on
-what is being printed, it tries to break the line at a readable place,
-rather than simply letting it overflow onto the following line.
-
-Normally _GDBN__ knows the size of the screen from the termcap data base
-together with the value of the @code{TERM} environment variable and the
-@code{stty rows} and @code{stty cols} settings. If this is not correct,
-you can override it with the @code{set height} and @code{set
-width} commands:
-
-@table @code
-@item set height @var{lpp}
-@itemx show height
-@itemx set width @var{cpl}
-@itemx show width
-@kindex set height
-@kindex set width
-@kindex show width
-@kindex show height
-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, _GDBN__ will 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.
-@end table
-
-@node Numbers, Messages/Warnings, Screen Size, Controlling _GDBN__
-@section Numbers
-@cindex number representation
-@cindex entering numbers
-You can always enter numbers in octal, decimal, or hexadecimal in _GDBN__ by
-the usual conventions: octal numbers begin with @samp{0}, decimal
-numbers end with @samp{.}, and hexadecimal numbers begin with @samp{0x}.
-Numbers that begin with none of these are, by default, entered in base
-10; likewise, the default display for numbers---when no particular
-format is specified---is base 10.  You can change the default base for
-both input and output with the @code{set radix} command.
-
-@table @code
-@kindex set radix
-@item set radix @var{base}
-Set the default base for numeric input and display.  Supported choices
-for @var{base} are decimal 8, 10, 16.  @var{base} must itself be
-specified either unambiguously or using the current default radix; for
-example, any of
-
-@example
-set radix 012
-set radix 10.
-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.
-
-@kindex show radix
-@item show radix
-Display the current default base for numeric input and display.
-
-@end table
-
-@node Messages/Warnings,  , Numbers, Controlling _GDBN__
-@section Optional Warnings and Messages
-By default, _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 _GDBN__ tell you when it does a lengthy internal operation, so
-you won't think it has crashed.
-
-Currently, the messages controlled by @code{set verbose} are those which
-announce that the symbol table for a source file is being read
-(@pxref{Files}, in the description of the command
-@code{symbol-file}).
-@c The following is the right way to do it, but emacs 18.55 doesn't support
-@c @ref, and neither the emacs lisp manual version of texinfmt or makeinfo
-@c is released.  
-@ignore
-see @code{symbol-file} in @ref{Files}).
-@end ignore
-
-@table @code
-@kindex set verbose
-@item set verbose on
-Enables _GDBN__'s output of certain informational messages.
-
-@item set verbose off
-Disables _GDBN__'s output of certain informational messages.
-
-@kindex show verbose
-@item show verbose
-Displays whether @code{set verbose} is on or off.
-@end table
-
-By default, if _GDBN__ encounters bugs in the symbol table of an object file,
-it prints a single message about each type of problem it finds, then 
-shuts up (@pxref{Symbol Errors}).  You can suppress these messages, or allow more than one such
-message to be printed if you want to see how frequent the problems are.
-
-@table @code
-@kindex set complaints
-@item set complaints @var{limit}
-Permits _GDBN__ to output @var{limit} complaints about each type of unusual
-symbols before becoming silent about the problem.  Set @var{limit} to
-zero to suppress all complaints; set it to a large number to prevent
-complaints from being suppressed.
-
-@kindex show complaints
-@item show complaints
-Displays how many symbol complaints _GDBN__ is permitted to produce.
-@end table
-
-By default, _GDBN__ is cautious, and asks what sometimes seem to be a
-lot of stupid questions to confirm certain commands.  For example, if
-you try to run a program which is already running:
-@example
-(_GDBP__) run
-The program being debugged has been started already.
-Start it from the beginning? (y or n) 
-@end example
-
-If you're willing to unflinchingly face the consequences of your own
-commands, you can disable this ``feature'':
-
-@table @code
-@kindex set confirm
-@cindex flinching
-@cindex confirmation
-@cindex stupid questions
-@item set confirm off
-Disables confirmation requests.
-
-@item set confirm on
-Enables confirmation requests (the default).
-
-@item show confirm
-@kindex show confirm
-Displays state of confirmation requests.
-@end table
-
-@node Sequences, Emacs, Controlling _GDBN__, Top
-@chapter Canned Sequences of Commands
-
-Aside from breakpoint commands (@pxref{Break Commands}), _GDBN__ provides two
-ways to store sequences of commands for execution as a unit:
-user-defined commands and command files.
-
-@menu
-* Define::			User-Defined Commands
-* Command Files::		Command Files
-* Output::			Commands for Controlled Output
-@end menu
-
-@node Define, Command Files, Sequences, Sequences
-@section User-Defined Commands
-
-@cindex user-defined command
-A @dfn{user-defined command} is a sequence of _GDBN__ commands to which you
-assign a new name as a command.  This is done with the @code{define}
-command.
-
-@table @code
-@item define @var{commandname}
-@kindex define
-Define a command named @var{commandname}.  If there is already a command
-by that name, you are asked to confirm that you want to redefine it.
-
-The definition of the command is made up of other _GDBN__ command lines,
-which are given following the @code{define} command.  The end of these
-commands is marked by a line containing @code{end}.
-
-@item document @var{commandname}
-@kindex document
-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
-the documentation you have specified.
-
-You may use the @code{document} command again to change the
-documentation of a command.  Redefining the command with @code{define}
-does not change the documentation.
-
-@item help user-defined
-@kindex help user-defined
-List all user-defined commands, with the first line of the documentation
-(if any) for each.
-
-@item info user
-@itemx info user @var{commandname}
-@kindex info user
-Display the _GDBN__ commands used to define @var{commandname} (but not its
-documentation).  If no @var{commandname} is given, display the
-definitions for all user-defined commands.
-@end table
-
-User-defined commands do not take arguments.  When they are executed, the
-commands of the definition are not printed.  An error in any command
-stops execution of the user-defined command.
-
-Commands that would ask for confirmation if used interactively proceed
-without asking when used inside a user-defined command.  Many _GDBN__ commands
-that normally print messages to say what they are doing omit the messages
-when used in a user-defined command.
-
-@node Command Files, Output, Define, Sequences
-@section Command Files
-
-@cindex command files
-A command file for _GDBN__ is a file of lines that are _GDBN__ commands.  Comments
-(lines starting with @kbd{#}) may also be included.  An empty line in a
-command file does nothing; it does not mean to repeat the last command, as
-it would from the terminal.
-
-@cindex init file
-@cindex @file{_GDBINIT__}
-When you start _GDBN__, it automatically executes commands from its
-@dfn{init files}.  These are files named @file{_GDBINIT__}.  _GDBN__
-reads the init file (if any) in your home directory and then the init
-file (if any) in the current working directory.  (The init files are not
-executed if you use the @samp{-nx} option; @pxref{Mode Options}.)  You
-can also request the execution of a command file with the @code{source}
-command:
-
-@table @code
-@item source @var{filename}
-@kindex source
-Execute the command file @var{filename}.
-@end table
-
-The lines in a command file are executed sequentially.  They are not
-printed as they are executed.  An error in any command terminates execution
-of the command file.
-
-Commands that would ask for confirmation if used interactively proceed
-without asking when used in a command file.  Many _GDBN__ commands that
-normally print messages to say what they are doing omit the messages
-when called from command files.
-
-@node Output,  , Command Files, Sequences
-@section Commands for Controlled Output
-
-During the execution of a command file or a user-defined command, normal
-_GDBN__ output is suppressed; the only output that appears is what is
-explicitly printed by the commands in the definition.  This section
-describes three commands useful for generating exactly the output you
-want.
-
-@table @code
-@item echo @var{text}
-@kindex echo
-@c I don't consider backslash-space a standard C escape sequence
-@c because it's 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.  @b{No
-newline will be 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 outputting a string with spaces at the
-beginning or the end, since leading and trailing spaces are otherwise
-trimmed from all arguments.  Thus, to print @samp{@ and foo =@ }, use the
-command @samp{echo \@ and foo = \@ }.
-@c FIXME: verify hard copy actually issues enspaces for '@ '!  Will this
-@c        confuse texinfo?
-
-A backslash at the end of @var{text} can be used, as in C, to continue
-the command onto subsequent lines.  For example,
-
-@example
-echo This is some text\n\
-which is continued\n\
-onto several lines.\n
-@end example
-
-produces the same output as
-
-@example
-echo This is some text\n
-echo which is continued\n
-echo onto several lines.\n
-@end example
-
-@item output @var{expression}
-@kindex output
-Print the value of @var{expression} and nothing but that value: no
-newlines, no @samp{$@var{nn} = }.  The value is not entered in the
-value history either.  @xref{Expressions} for more information on
-expressions. 
-
-@item output/@var{fmt} @var{expression}
-Print the value of @var{expression} in format @var{fmt}.  You can use
-the same formats as for @code{print}; @pxref{Output formats}, for more
-information.
-
-@item printf @var{string}, @var{expressions}@dots{}
-@kindex printf
-Print the values of the @var{expressions} under the control of
-@var{string}.  The @var{expressions} are separated by commas and may
-be either numbers or pointers.  Their values are printed as specified
-by @var{string}, exactly as if the program were to execute
-
-@example
-printf (@var{string}, @var{expressions}@dots{});
-@end example
-
-For example, you can print two values in hex like this:
-
-@example
-printf "foo, bar-foo = 0x%x, 0x%x\n", foo, bar-foo
-@end example
-
-The only backslash-escape sequences that you can use in the format
-string are the simple ones that consist of backslash followed by a
-letter.
-@end table
-
-@node Emacs, _GDBN__ Bugs, Sequences, Top
-@chapter Using _GDBN__ under GNU Emacs
-
-@cindex emacs
-A special interface allows you to use GNU Emacs to view (and
-edit) the source files for the program you are debugging with
-_GDBN__.
-
-To use this interface, use the command @kbd{M-x gdb} in Emacs.  Give the
-executable file you want to debug as an argument.  This command starts
-_GDBN__ as a subprocess of Emacs, with input and output through a newly
-created Emacs buffer.
-
-Using _GDBN__ under Emacs is just like using _GDBN__ normally except for two
-things:
-
-@itemize @bullet
-@item
-All ``terminal'' input and output goes through the Emacs buffer.  
-@end itemize
-
-This applies both to _GDBN__ commands and their output, and to the input
-and output done by the program you are debugging.
-
-This is useful because it means that you can copy the text of previous
-commands and input them again; you can even use parts of the output
-in this way.
-
-All the facilities of Emacs' Shell mode are available for this purpose.
-
-@itemize @bullet
-@item
-_GDBN__ displays source code through Emacs.  
-@end itemize
-
-Each time _GDBN__ displays a stack frame, Emacs automatically finds the
-source file for that frame and puts an arrow (_0__@samp{=>}_1__) at the
-left margin of the current line.  Emacs uses a separate buffer for
-source display, and splits the window to show both your _GDBN__ session
-and the source.
-
-Explicit _GDBN__ @code{list} or search commands still produce output as
-usual, but you probably will have no reason to use them.
-
-@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
-appear to show your source.  _GDBN__ can find programs by searching your
-environment's @code{PATH} variable, so the _GDBN__ input and output
-session will proceed normally; but Emacs doesn't get enough information
-back from _GDBN__ to locate the source files in this situation.  To
-avoid this problem, either start _GDBN__ mode from the directory where
-your program resides, or specify a full path name when prompted for the
-@kbd{M-x gdb} argument.
-
-A similar confusion can result if you use the _GDBN__ @code{file} command to
-switch to debugging a program in some other location, from an existing
-_GDBN__ buffer in Emacs.
-@end quotation
-
-By default, @kbd{M-x gdb} calls the program called @file{gdb}.  If
-you need to call _GDBN__ by a different name (for example, if you keep
-several configurations around, with different names) you can set the
-Emacs variable @code{gdb-command-name}; for example,
-@example
-(setq gdb-command-name "mygdb")
-@end 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
-``@code{mygdb}'' instead.
-
-In the _GDBN__ I/O buffer, you can use these special Emacs commands in
-addition to the standard Shell mode commands:
-
-@table @kbd
-@item C-h m
-Describe the features of Emacs' _GDBN__ Mode.
-
-@item M-s
-Execute to another source line, like the _GDBN__ @code{step} command; also
-update the display window to show the current file and location.
-
-@item M-n
-Execute to next source line in this function, skipping all function
-calls, like the _GDBN__ @code{next} command.  Then update the display window
-to show the current file and location.
-
-@item M-i
-Execute one instruction, like the _GDBN__ @code{stepi} command; update
-display window accordingly.
-
-@item M-x gdb-nexti
-Execute to next instruction, using the _GDBN__ @code{nexti} command; update
-display window accordingly.
-
-@item C-c C-f
-Execute until exit from the selected stack frame, like the _GDBN__
-@code{finish} command.
-
-@item M-c
-Continue execution of the program, like the _GDBN__ @code{continue}
-command.  @emph{Warning:} In Emacs v19, this command is @kbd{C-c C-p}.
-
-@item M-u
-Go up the number of frames indicated by the numeric argument
-(@pxref{Arguments, , Numeric Arguments, emacs, The GNU Emacs Manual}),
-like the _GDBN__ @code{up} command.  @emph{Warning:} In Emacs v19, this
-command is @kbd{C-c C-u}.@refill
-
-@item M-d
-Go down the number of frames indicated by the numeric argument, like the
-_GDBN__ @code{down} command.  @emph{Warning:} In Emacs v19, this command
-is @kbd{C-c C-d}.
-
-@item C-x &
-Read the number where the cursor is positioned, and insert it at the end
-of the _GDBN__ I/O buffer.  For example, if you wish to disassemble code
-around an address that was displayed earlier, type @kbd{disassemble};
-then move the cursor to the address display, and pick up the
-argument for @code{disassemble} by typing @kbd{C-x &}.  
-
-You can customize this further on the fly 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 flag that you
-wish special formatting, and act 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.
-
-@end table
-
-In any source file, the Emacs command @kbd{C-x SPC} (@code{gdb-break})
-tells _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 _GDBN__ buffer, to
-request a frame display; when you run under Emacs, this will recreate
-the source buffer if necessary to show you the context of the current
-frame.
-
-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 _GDBN__
-communicates with Emacs in terms of line numbers.  If you add or
-delete lines from the text, the line numbers that _GDBN__ knows will cease
-to correspond properly to the code.
-
-@c The following dropped because Epoch is nonstandard.  Reactivate
-@c if/when v19 does something similar. ---pesch@cygnus.com 19dec1990
-@ignore
-@kindex emacs epoch environment  
-@kindex epoch
-@kindex inspect
-
-Version 18 of Emacs has a built-in window system called the @code{epoch}
-environment.  Users of this environment can use a new command,
-@code{inspect} which performs identically to @code{print} except that
-each value is printed in its own window.
-@end ignore
-
-@node _GDBN__ Bugs, Renamed Commands, Emacs, Top
-@c  node-name,  next,  previous,  up
-@chapter Reporting Bugs in _GDBN__
-@cindex Bugs in _GDBN__
-@cindex Reporting Bugs in _GDBN__
-
-Your bug reports play an essential role in making _GDBN__ reliable.
-
-Reporting a bug may help you by bringing a solution to your problem, or it
-may not.  But in any case the principal function of a bug report is to help
-the entire community by making the next version of _GDBN__ work better.  Bug
-reports are your contribution to the maintenance of _GDBN__.
-
-In order for a bug report to serve its purpose, you must include the
-information that enables us to fix the bug.
-
-@menu
-* Bug Criteria::		Have You Found a Bug?
-* Bug Reporting::		How to Report Bugs
-@end menu
-
-@node Bug Criteria, Bug Reporting, _GDBN__ Bugs, _GDBN__ Bugs
-@section Have You Found a Bug?
-@cindex Bug Criteria
-
-If you are not sure whether you have found a bug, here are some guidelines:
-
-@itemize @bullet
-@item
-@cindex Fatal Signal
-@cindex Core Dump
-If the debugger gets a fatal signal, for any input whatever, that is a
-_GDBN__ bug.  Reliable debuggers never crash.
-
-@item
-@cindex error on Valid Input
-If _GDBN__ produces an error message for valid input, that is a bug.
-
-@item
-@cindex Invalid Input
-If _GDBN__ does not produce an error message for invalid input,
-that is a bug.  However, you should note that your idea of
-``invalid input'' might be our idea of ``an extension'' or ``support
-for traditional practice''.
-
-@item
-If you are an experienced user of debugging tools, your suggestions
-for improvement of _GDBN__ are welcome in any case.
-@end itemize
-
-@node Bug Reporting,  , Bug Criteria, _GDBN__ Bugs
-@section How to Report Bugs
-@cindex Bug Reports
-@cindex Compiler Bugs, Reporting
-
-A number of companies and individuals offer support for GNU products.
-If you obtained _GDBN__ from a support organization, we recommend you
-contact that organization first. 
-
-Contact information for many support companies and individuals is
-available in the file @file{etc/SERVICE} in the GNU Emacs distribution.
-
-In any event, we also recommend that you send bug reports for _GDBN__ to one
-of these addresses:
-
-@example
-bug-gdb@@prep.ai.mit.edu
-@{ucbvax|mit-eddie|uunet@}!prep.ai.mit.edu!bug-gdb
-@end example
-
-@strong{Do not send bug reports to @samp{info-gdb}, or to
-@samp{help-gdb}, or to any newsgroups.} Most users of _GDBN__ do not want to
-receive bug reports.  Those that do, have arranged to receive @samp{bug-gdb}.
-
-The mailing list @samp{bug-gdb} has a newsgroup which serves as a
-repeater.  The mailing list and the newsgroup carry exactly the same
-messages.  Often people think of posting bug reports to the newsgroup
-instead of mailing them.  This appears to work, but it has one problem
-which can be crucial: a newsgroup posting often lacks a mail path
-back to the sender.  Thus, if we need to ask for more information, we
-may be unable to reach you.  For this reason, it is better to send bug
-reports to the mailing list.
-
-As a last resort, send bug reports on paper to:
-
-@example
-GNU Debugger Bugs
-545 Tech Square
-Cambridge, MA 02139
-@end example
-
-The fundamental principle of reporting bugs usefully is this:
-@strong{report all the facts}.  If you are not sure whether to state a
-fact or leave it out, state it!
-
-Often people omit facts because they think they know what causes the
-problem and assume that some details don't matter.  Thus, you might
-assume that the name of the variable you use in an example does not matter.
-Well, probably it doesn't, but one cannot be sure.  Perhaps the bug is a
-stray memory reference which happens to fetch from the location where that
-name is stored in memory; perhaps, if the name were different, the contents
-of that location would fool the debugger into doing the right thing despite
-the bug.  Play it safe and give a specific, complete example.  That is the
-easiest thing for you to do, and the most helpful.
-
-Keep in mind that the purpose of a bug report is to enable us to fix
-the bug if it is new to us.  It isn't as important what happens if
-the bug is already known.  Therefore, always write your bug reports on
-the assumption that the bug has not been reported previously.
-
-Sometimes people give a few sketchy facts and ask, ``Does this ring a
-bell?''  Those bug reports are useless, and we urge everyone to
-@emph{refuse to respond to them} except to chide the sender to report
-bugs properly.
-
-To enable us to fix the bug, you should include all these things:
-
-@itemize @bullet
-@item
-The version of _GDBN__.  _GDBN__ announces it if you start with no
-arguments; you can also print it at any time using @code{show version}.
-
-Without this, we won't know whether there is any point in looking for
-the bug in the current version of _GDBN__.
-
-@item
-A complete input script, and all necessary source files, that will
-reproduce the bug.  
-
-@item
-What compiler (and its version) was used to compile _GDBN__---e.g.
-``_GCC__-1.37.1''.
-
-@item
-The command arguments you gave the compiler to compile your example and
-observe the bug.  For example, did you use @samp{-O}?  To guarantee
-you won't omit something important, list them all.
-
-If we were to try to guess the arguments, we would probably guess wrong
-and then we might not encounter the bug.
-
-@item
-The type of machine you are using, and the operating system name and
-version number.
-
-@item
-A description of what behavior you observe that you believe is
-incorrect.  For example, ``It gets a fatal signal.''
-
-Of course, if the bug is that _GDBN__ gets a fatal signal, then we will
-certainly notice it.  But if the bug is incorrect output, we might not
-notice unless it is glaringly wrong.  We are human, after all.  You
-might as well not give us a chance to make a mistake.
-
-Even if the problem you experience is a fatal signal, you should still
-say so explicitly.  Suppose something strange is going on, such as,
-your copy of _GDBN__ is out of synch, or you have encountered a
-bug in the C library on your system.  (This has happened!)  Your copy
-might crash and ours would not.  If you told us to expect a crash,
-then when ours fails to crash, we would know that the bug was not
-happening for us.  If you had not told us to expect a crash, then we
-would not be able to draw any conclusion from our observations.
-
-@item
-If you wish to suggest changes to the _GDBN__ source, send us context
-diffs.  If you even discuss something in the _GDBN__ source, refer to
-it by context, not by line number.
-
-The line numbers in our development sources won't match those in your
-sources.  Your line numbers would convey no useful information to us.
-
-@end itemize
-
-Here are some things that are not necessary:
-
-@itemize @bullet
-@item
-A description of the envelope of the bug.
-
-Often people who encounter a bug spend a lot of time investigating
-which changes to the input file will make the bug go away and which
-changes will not affect it.
-
-This is often time consuming and not very useful, because the way we
-will find the bug is by running a single example under the debugger
-with breakpoints, not by pure deduction from a series of examples.
-We recommend that you save your time for something else.
-
-Of course, if you can find a simpler example to report @emph{instead}
-of the original one, that is a convenience for us.  Errors in the
-output will be easier to spot, running under the debugger will take
-less time, etc. 
-
-However, simplification is not vital; if you don't want to do this,
-report the bug anyway and send us the entire test case you used.
-
-@item
-A patch for the bug.
-
-A patch for the bug does help us if it is a good one.  But don't omit
-the necessary information, such as the test case, on the assumption that
-a patch is all we need.  We might see problems with your patch and decide
-to fix the problem another way, or we might not understand it at all.
-
-Sometimes with a program as complicated as _GDBN__ it is very hard to
-construct an example that will make the program follow a certain path
-through the code.  If you don't send us the example, we won't be able
-to construct one, so we won't be able to verify that the bug is fixed.
-
-And if we can't understand what bug you are trying to fix, or why your
-patch should be an improvement, we won't install it.  A test case will
-help us to understand.
-
-@item
-A guess about what the bug is or what it depends on.
-
-Such guesses are usually wrong.  Even we can't guess right about such
-things without first using the debugger to find the facts.
-@end itemize
-
-@iftex
-@include rdl-apps.texinfo
-@end iftex
-
-@node Renamed Commands, Installing _GDBN__, _GDBN__ Bugs, Top
-@appendix Commands Renamed in 4.0
-
-The following commands were renamed in _GDBN__ 4.0, in order to make the
-command set as a whole more consistent and easier to use and remember:
-
-@kindex add-syms                   
-@kindex delete environment         
-@kindex info copying               
-@kindex info convenience           
-@kindex info directories           
-@kindex info editing               
-@kindex info history               
-@kindex info targets               
-@kindex info values                
-@kindex info version               
-@kindex info warranty              
-@kindex set addressprint      
-@kindex set arrayprint        
-@kindex set prettyprint       
-@kindex set screen-height     
-@kindex set screen-width      
-@kindex set unionprint        
-@kindex set vtblprint         
-@kindex set demangle          
-@kindex set asm-demangle      
-@kindex set sevenbit-strings  
-@kindex set array-max         
-@kindex set caution           
-@kindex set history write     
-@kindex show addressprint      
-@kindex show arrayprint        
-@kindex show prettyprint       
-@kindex show screen-height     
-@kindex show screen-width      
-@kindex show unionprint        
-@kindex show vtblprint         
-@kindex show demangle          
-@kindex show asm-demangle      
-@kindex show sevenbit-strings  
-@kindex show array-max         
-@kindex show caution           
-@kindex show history write     
-@kindex unset                      
-
-@ifinfo
-OLD COMMAND                NEW COMMAND
----------------            ----------------------------------
-add-syms                   add-symbol-file
-delete environment         unset environment
-info convenience           show convenience
-info copying               show copying
-info directories           show directories     
-info editing               show commands
-info history               show values
-info targets               help target
-info values                show values
-info version               show version
-info warranty              show warranty
-set/show addressprint      set/show print address
-set/show array-max         set/show print elements
-set/show arrayprint        set/show print array
-set/show asm-demangle      set/show print asm-demangle
-set/show caution           set/show confirm
-set/show demangle          set/show print demangle
-set/show history write     set/show history save
-set/show prettyprint       set/show print pretty
-set/show screen-height     set/show height
-set/show screen-width      set/show width
-set/show sevenbit-strings  set/show print sevenbit-strings
-set/show unionprint        set/show print union
-set/show vtblprint         set/show print vtbl
-
-unset                      [ No longer an alias for delete ]
-@end ifinfo
-
-@tex
-\vskip \parskip\vskip \baselineskip
-\halign{\tt #\hfil &\qquad#&\tt #\hfil\cr
-{\bf Old Command}         &&{\bf New Command}\cr
-add-syms                  &&add-symbol-file\cr
-delete environment        &&unset environment\cr
-info convenience          &&show convenience\cr
-info copying              &&show copying\cr
-info directories          &&show directories     \cr
-info editing              &&show commands\cr
-info history              &&show values\cr
-info targets              &&help target\cr
-info values               &&show values\cr
-info version              &&show version\cr
-info warranty             &&show warranty\cr
-set{\rm / }show addressprint     &&set{\rm / }show print address\cr
-set{\rm / }show array-max        &&set{\rm / }show print elements\cr
-set{\rm / }show arrayprint       &&set{\rm / }show print array\cr
-set{\rm / }show asm-demangle     &&set{\rm / }show print asm-demangle\cr
-set{\rm / }show caution          &&set{\rm / }show confirm\cr
-set{\rm / }show demangle         &&set{\rm / }show print demangle\cr
-set{\rm / }show history write    &&set{\rm / }show history save\cr
-set{\rm / }show prettyprint      &&set{\rm / }show print pretty\cr
-set{\rm / }show screen-height    &&set{\rm / }show height\cr
-set{\rm / }show screen-width     &&set{\rm / }show width\cr
-set{\rm / }show sevenbit-strings &&set{\rm / }show print sevenbit-strings\cr
-set{\rm / }show unionprint       &&set{\rm / }show print union\cr
-set{\rm / }show vtblprint        &&set{\rm / }show print vtbl\cr
-\cr
-unset                     &&\rm(No longer an alias for delete)\cr
-}
-@end tex
-
-@node Installing _GDBN__, Copying, Renamed Commands, Top
-@appendix Installing _GDBN__
-@cindex configuring _GDBN__
-@cindex installation
-
-The script @code{config.gdb} automates the process of preparing _GDBN__
-for installation; you can then use @code{make} to actually build it.
-The best way to build _GDBN__ is in a subdirectory that records the
-configuration options used; this gives you a clean way of building
-_GDBN__ binaries with several different configuration options.
-@code{config.gdb} doesn't depend on this---it's just a good habit.  For
-example, assuming the _GDBN__ source is in a directory called
-``@code{gdb-4.0}'': 
-
-@example
-cd gdb-4.0
-mkdir =sun3os4
-cd =sun3os4
-../config.gdb sun3os4
-make
-@end example
-
-@noindent
-will install _GDBN__ on a Sun 3 running SunOS 4.  
-
-@table @code
-@kindex config.gdb
-@item config.gdb @var{machine}
-@itemx config.gdb -srcdir=@var{dir} @var{machine}
-This is the most usual way of configuring _GDBN__; to debug programs running
-on the same machine as _GDBN__ itself.  If you wish to build the _GDBN__ binaries
-in a completely different directory from the sources, specify a path to
-the source directory using the @samp{-srcdir} option.
-
-@item config.gdb -host
-@cindex host environments
-Display a list of supported host environments for _GDBN__.
-
-@item config.gdb @var{host} @var{target}
-@itemx config.gdb -srcdir=@var{dir} @var{host} @var{target}
-@cindex cross-debugging
-_GDBN__ can also be used as a cross-debugger, running on a machine of one
-type while debugging a program running on a machine of another type.
-You configure it this way by specifying first the @var{host}, then the
-@var{target} environment on the @code{config.gdb} argument list; the
-@var{host} is where _GDBN__ runs, and the @var{target} is where your program
-runs. @xref{Remote}.  Again, you can use @samp{-srcdir} to specify a
-path to the _GDBN__ source.
-
-@item config.gdb -target
-@cindex target environments
-Display a list of supported target environments for _GDBN__.
-@end table
-
-@node Copying, Index, Installing _GDBN__, Top
-@appendix Copying GDB
-@c this is an attempt to kluge around what may be a bug in texinfo;
-@c @xrefs to this node came out pointing several pages further down when
-@c the @node was immediately followed by @unnumbered.
-@c While we're at it, might as well give an Appendix heading that
-@c matches RMS' preferred nodename "Copying".
-
-@unnumbered GNU GENERAL PUBLIC LICENSE
-@center Version 1, February 1989
-
-@display
-Copyright @copyright{} 1989 Free Software Foundation, Inc.
-675 Mass Ave, Cambridge, MA 02139, USA
-
-Everyone is permitted to copy and distribute verbatim copies
-of this license document, but changing it is not allowed.
-@end display
-
-@unnumberedsec Preamble
-
-  The license agreements of most software companies try to keep users
-at the mercy of those companies.  By contrast, our General Public
-License is intended to guarantee your freedom to share and change free
-software---to make sure the software is free for all its users.  The
-General Public License applies to the Free Software Foundation's
-software and to any other program whose authors commit to using it.
-You can use it for your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Specifically, the General Public License is designed to make
-sure that you have the freedom to give away or sell copies of free
-software, that you receive source code or can get it if you want it,
-that you can change the software or use pieces of it in new free
-programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of a such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must tell them their rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-@iftex
-@unnumberedsec TERMS AND CONDITIONS
-@end iftex
-@ifinfo
-@center TERMS AND CONDITIONS
-@end ifinfo
-
-@enumerate
-@item
-This License Agreement applies to any program or other work which
-contains a notice placed by the copyright holder saying it may be
-distributed under the terms of this General Public License.  The
-``Program'', below, refers to any such program or work, and a ``work based
-on the Program'' means either the Program or any work containing the
-Program or a portion of it, either verbatim or with modifications.  Each
-licensee is addressed as ``you''.
-
-@item
-You may copy and distribute verbatim copies of the Program's source
-code as you receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice and
-disclaimer of warranty; keep intact all the notices that refer to this
-General Public License and to the absence of any warranty; and give any
-other recipients of the Program a copy of this General Public License
-along with the Program.  You may charge a fee for the physical act of
-transferring a copy.
-
-@item
-You may modify your copy or copies of the Program or any portion of
-it, and copy and distribute such modifications under the terms of Paragraph
-1 above, provided that you also do the following:
-
-@itemize @bullet
-@item
-cause the modified files to carry prominent notices stating that
-you changed the files and the date of any change; and
-
-@item
-cause the whole of any work that you distribute or publish, that
-in whole or in part contains the Program or any part thereof, either
-with or without modifications, to be licensed at no charge to all
-third parties under the terms of this General Public License (except
-that you may choose to grant warranty protection to some or all
-third parties, at your option).
-
-@item
-If the modified program normally reads commands interactively when
-run, you must cause it, when started running for such interactive use
-in the simplest and most usual way, to print or display an
-announcement including an appropriate copyright notice and a notice
-that there is no warranty (or else, saying that you provide a
-warranty) and that users may redistribute the program under these
-conditions, and telling the user how to view a copy of this General
-Public License.
-
-@item
-You may charge a fee for the physical act of transferring a
-copy, and you may at your option offer warranty protection in
-exchange for a fee.
-@end itemize
-
-Mere aggregation of another independent work with the Program (or its
-derivative) on a volume of a storage or distribution medium does not bring
-the other work under the scope of these terms.
-
-@item
-You may copy and distribute the Program (or a portion or derivative of
-it, under Paragraph 2) in object code or executable form under the terms of
-Paragraphs 1 and 2 above provided that you also do one of the following:
-
-@itemize @bullet
-@item
-accompany it with the complete corresponding machine-readable
-source code, which must be distributed under the terms of
-Paragraphs 1 and 2 above; or,
-
-@item
-accompany it with a written offer, valid for at least three
-years, to give any third party free (except for a nominal charge
-for the cost of distribution) a complete machine-readable copy of the
-corresponding source code, to be distributed under the terms of
-Paragraphs 1 and 2 above; or,
-
-@item
-accompany it with the information you received as to where the
-corresponding source code may be obtained.  (This alternative is
-allowed only for noncommercial distribution and only if you
-received the program in object code or executable form alone.)
-@end itemize
-
-Source code for a work means the preferred form of the work for making
-modifications to it.  For an executable file, complete source code means
-all the source code for all modules it contains; but, as a special
-exception, it need not include source code for modules which are standard
-libraries that accompany the operating system on which the executable
-file runs, or for standard header files or definitions files that
-accompany that operating system.
-
-@item
-You may not copy, modify, sublicense, distribute or transfer the
-Program except as expressly provided under this General Public License.
-Any attempt otherwise to copy, modify, sublicense, distribute or transfer
-the Program is void, and will automatically terminate your rights to use
-the Program under this License.  However, parties who have received
-copies, or rights to use copies, from you under this General Public
-License will not have their licenses terminated so long as such parties
-remain in full compliance.
-
-@item
-By copying, distributing or modifying the Program (or any work based
-on the Program) you indicate your acceptance of this license to do so,
-and all its terms and conditions.
-
-@item
-Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the original
-licensor to copy, distribute or modify the Program subject to these
-terms and conditions.  You may not impose any further restrictions on the
-recipients' exercise of the rights granted herein.
-
-@item
-The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of the license which applies to it and ``any
-later version'', you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-the license, you may choose any version ever published by the Free Software
-Foundation.
-
-@item
-If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-@iftex
-@heading NO WARRANTY
-@end iftex
-@ifinfo
-@center NO WARRANTY
-@end ifinfo
-
-@item
-BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-@item
-IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
-ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
-ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
-LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
-SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
-WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-@end enumerate
-
-@iftex
-@heading END OF TERMS AND CONDITIONS
-@end iftex
-@ifinfo
-@center END OF TERMS AND CONDITIONS
-@end ifinfo
-
-@page
-@unnumberedsec Applying These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to humanity, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these
-terms.
-
-  To do so, attach the following notices to the program.  It is safest to
-attach them to the start of each source file to most effectively convey
-the exclusion of warranty; and each file should have at least the
-``copyright'' line and a pointer to where the full notice is found.
-
-@smallexample
-@var{one line to give the program's name and a brief idea of what it does.}
-Copyright (C) 19@var{yy}  @var{name of author}
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-@end smallexample
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-@smallexample
-Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
-Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-This is free software, and you are welcome to redistribute it
-under certain conditions; type `show c' for details.
-@end smallexample
-
-The hypothetical commands `show w' and `show c' should show the
-appropriate parts of the General Public License.  Of course, the
-commands you use may be called something other than `show w' and `show
-c'; they could even be mouse-clicks or menu items---whatever suits your
-program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a ``copyright disclaimer'' for the program, if
-necessary.  Here is a sample; alter the names:
-
-@smallexample
-Yoyodyne, Inc., hereby disclaims all copyright interest in the
-program `Gnomovision' (a program to direct compilers to make passes
-at assemblers) written by James Hacker.
-
-@var{signature of Ty Coon}, 1 April 1989
-Ty Coon, President of Vice
-@end smallexample
-
-That's all there is to it!
+_fi__(0)
+_include__(gdb.top-m4)
+_include__(gdb.sample-m4)
+_include__(gdb.invoc-m4)
+_include__(gdb.cmds-m4)
+_include__(gdb.run-m4)
+_include__(gdb.stop-m4)
+_include__(gdb.stack-m4)
+_include__(gdb.src-m4)
+_include__(gdb.data-m4)
+_include__(gdb.symb-m4)
+_include__(gdb.alter-m4)
+_include__(gdb.files-m4)
+_include__(gdb.tgts-m4)
+_include__(gdb.ctl-m4)
+_include__(gdb.canned-m4)
+_include__(gdb.emacs-m4)
+_include__(gdb.bugs-m4)
+_include__(gdb.rdln-m4)
+_include__(gdb.rename-m4)
+_include__(gdb.install-m4)
+_include__(gdb.gpl-m4)
 
 @node Index,  , Copying, Top
 @unnumbered Index