Merged in new doc on language setting, C, and Mod-2 by Andrew Beers;

cleanups to node structure.

3 files changed, 8264 insertions, 0 deletions

diff --git a/gdb/doc/interim-gdb.texinfo b/gdb/doc/interim-gdb.texinfo
new file mode 100755
index 0000000..c608acf
--- /dev/null
+++ b/gdb/doc/interim-gdb.texinfo
@@ -0,0 +1,7824 @@
+_dnl__                                          -*-Texinfo-*-
+_dnl__ Copyright (c) 1988 1989 1990 1991 Free Software Foundation, Inc.
+\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
+@c of m4 macros called "pretex.m4".  If you see <_if__> and <_fi__>
+@c scattered around the source, you have the full source before
+@c preprocessing; if you don't, you have the source configured for
+@c _HOST__ architectures (and you can of course get the full source,
+@c with all configurations, from wherever you got this).
+_if__(0)
+
+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
+_1__
+will produce (assuming your path finds either GNU m4 >= 0.84, 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).
+
+_fi__(0)
+@tex
+\def\$#1${{#1}}  % Kluge: collect RCS revision info without $...$
+\xdef\manvers{\$Revision$}  % For use in headers, footers too
+@end tex
+@c
+@syncodeindex ky cp
+@c FOR UPDATES LEADING TO THIS DRAFT, GDB CHANGELOG CONSULTED BETWEEN:
+@c Thu Aug 22 14:05:47 1991  Stu Grossman  (grossman 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
+@c @smallbook
+@setchapternewpage odd
+_if__(_GENERIC__)
+@settitle Using _GDBN__ (v4.0)
+_fi__(_GENERIC__)
+_if__(!_GENERIC__)
+@settitle Using _GDBN__ v4.0 (_HOST__)
+_fi__(!_GENERIC__)
+@iftex
+@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 July 1991
+@author{Richard M. Stallman@qquad @hfill Free Software Foundation}
+@author{Roland H. Pesch@qquad @hfill Cygnus Support}
+@page
+@tex
+{\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::                    _GDBN__ Commands
+* Running::                     Running Programs Under _GDBN__
+* Stopping::                    Stopping and Continuing
+* Stack::                       Examining the Stack
+* Source::                      Examining Source Files
+* Data::                        Examining Data
+* Languages::                   Using _GDBN__ with Different Languages
+* Symbols::                     Examining the Symbol Table
+* Altering::                    Altering Execution
+* _GDBN__ Files::                   _GDBN__'s 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
+
+ --- The Detailed Node Listing ---
+
+Summary of _GDBN__
+
+* Free Software::               Free Software
+* Contributors::                Contributors to _GDBN__
+
+Getting In and Out of _GDBN__
+
+* Starting _GDBN__::                Starting _GDBN__
+* Leaving _GDBN__::                 Leaving _GDBN__
+* Shell Commands::              Shell Commands
+
+Starting _GDBN__
+
+* File Options::                Choosing Files
+* Mode Options::                Choosing Modes
+
+_GDBN__ Commands
+
+* Command Syntax::              Command Syntax
+* Help::                        Getting Help
+
+Running Programs Under _GDBN__
+
+* 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
+
+Stopping and Continuing
+
+* Breakpoints::                 Breakpoints, Watchpoints, and Exceptions
+* Continuing and Stepping::     Resuming Execution
+* Signals::                     Signals
+
+Breakpoints, Watchpoints, and Exceptions
+
+* 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::        ``Cannot insert breakpoints''
+
+Examining the Stack
+
+* Frames::                      Stack Frames
+* Backtrace::                   Backtraces
+* Selection::                   Selecting a Frame
+* Frame Info::                  Information on a Frame
+
+Examining Source Files
+
+* List::                        Printing Source Lines
+* Search::                      Searching Source Files
+* Source Path::                 Specifying Source Directories
+* Machine Code::                Source and Machine Code
+
+Examining Data
+
+* 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
+
+Using GDB with Different Languages
+
+* Setting::                     Switching between source languages
+* Show::                        Displaying the language
+* Checks::                      Type and Range checks
+* Support::                     Supported languages
+
+Switching between source languages
+
+* Manually::                    Setting the working language manually
+* Automatically::               Having GDB infer the source language
+
+Type and range Checking
+
+* Type Checking::               An overview of type checking
+* Range Checking::              An overview of range checking
+
+Supported Languages
+
+* C::                           C and C++
+* Modula-2::                    Modula-2
+
+C and C++
+
+* C Operators::                 C and C++ Operators
+* C Constants::                 C and C++ Constants
+* Cplusplus expressions::       C++ Expressions
+* C Defaults::                  Default settings for C and C++
+* C Checks::                    C and C++ Type and Range Checks
+* Debugging C::                 _GDBN__ and C
+* Debugging C plus plus::       Special features for C++
+
+Modula-2
+
+* M2 Operators::                Built-in operators
+* Builtin Func/Proc::           Built-in Functions and Procedures
+* M2 Constants::                Modula-2 Constants
+* M2 Defaults::                 Default settings for Modula-2
+* Deviations::                  Deviations from standard Modula-2
+* M2 Checks::                   Modula-2 Type and Range Checks
+* M2 Scope::                    The scope operators @code{::} and @code{.}
+* GDB/M2::                      GDB and Modula-2
+
+Altering Execution
+
+* 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
+
+_GDBN__'s Files
+
+* Files::                       Commands to Specify Files
+* Symbol Errors::               Errors Reading Symbol Files
+
+Specifying a Debugging Target 
+
+* Active Targets::              Active Targets
+* Target Commands::             Commands for Managing Targets
+* Remote::                      Remote Debugging
+
+Remote Debugging
+
+* i960-Nindy Remote::           _GDBN__ with a Remote i960 (Nindy)
+* EB29K Remote::                _GDBN__ with a Remote EB29K
+* VxWorks Remote::              _GDBN__ and VxWorks
+
+_GDBN__ with a Remote i960 (Nindy)
+
+* Nindy Startup::               Startup with Nindy
+* Nindy Options::               Options for Nindy
+* Nindy reset::                 Nindy Reset Command
+
+_GDBN__ with a Remote EB29K
+
+* Comms (EB29K)::               Communications Setup
+* gdb-EB29K::                   EB29K cross-debugging
+* Remote Log::                  Remote Log
+
+_GDBN__ and VxWorks
+
+* VxWorks connection::          Connecting to VxWorks
+* VxWorks download::            VxWorks Download
+* VxWorks attach::              Running Tasks
+
+Controlling _GDBN__
+
+* Prompt::                      Prompt
+* Editing::                     Command Editing
+* History::                     Command History
+* Screen Size::                 Screen Size
+* Numbers::                     Numbers
+* Messages/Warnings::           Optional Warnings and Messages
+
+Canned Sequences of Commands
+
+* Define::                      User-Defined Commands
+* Command Files::               Command Files
+* Output::                      Commands for Controlled Output
+
+Reporting Bugs in _GDBN__
+
+* Bug Criteria::                Have You Found a Bug?
+* Bug Reporting::               How to Report Bugs
+
+Installing GDB
+
+* Subdirectories::              Configuration subdirectories
+* Config Names::                Specifying names for hosts and targets
+* configure Options::           Summary of options for configure
+* Formatting Manual::           How to format and print GDB documentation
+@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
+
+You can use _GDBN__ to debug programs written in C, C++, and Modula-2.
+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, and of many other 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 (releases 4.1, 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.
+
+Andrew Beers of SUNY Buffalo wrote the language-switching code and
+the Modula-2 support, and contributed the Languages chapter of this
+manual. 
+
+@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.  The
+command @code{load} can download programs into a remote system.  Serial
+stubs are available for Motorola 680x0 and Intel 80386 remote systems;
+_GDBN__ also supports debugging realtime processes running under
+VxWorks, using SunRPC Remote Procedure Calls over TCP/IP to talk to a
+debugger stub on the target system.  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 Wide Output
+Commands that issue wide output now insert newlines at places designed
+to make the output more readable.
+
+@item Object Code Formats
+_GDBN__ uses a new library called the Binary File Descriptor (BFD)
+Library 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 and Ports
+Compile-time configuration (to select a particular architecture and
+operating system) is much easier.  The script @code{configure} now
+allows you to configure _GDBN__ as either a native debugger or a
+cross-debugger. @xref{Installing _GDBN__} for details on how to
+configure and on what architectures are now available.
+
+@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 C++
+_GDBN__ now supports C++ multiple inheritance (if used with a GCC
+version 2 compiler), and also has limited support for C++ exception
+handling, with the commands @code{catch} and @code{info catch}: _GDBN__
+can break when an exception is raised, before the stack is peeled back
+to the exception handler's context.
+
+@item Modula-2
+_GDBN__ now has preliminary support for the GNU Modula-2 compiler,
+currently under development at the State University of New York at
+Buffalo.  Coordinated development of both _GDBN__ and the GNU Modula-2
+compiler will continue through the fall of 1991 and into 1992.  Other
+Modula-2 compilers are currently not supported, and attempting to debug
+programs compiled with them will likely result in an error as the symbol
+table of the executable is read in.
+
+@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 Shared Libraries
+_GDBN__ 4.0 can debug programs and core files that use SunOS shared
+libraries.  You can load symbols from a shared library with the command
+@code{sharedlibrary} (@pxref{Files}).
+
+@item Reference Card
+_GDBN__ 4.0 has a reference card; @xref{Formatting Manual} for
+instructions on printing it.
+
+@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__ reads only enough symbol data to know where to find the rest
+when needed; as a result, the first prompt comes up very quickly.  We
+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
+
+You can, instead, specify a process ID as a second argument, if you want
+to debug a running process:
+@example
+_GDBP__ program 1234
+@end example
+@noindent
+would attach _GDBN__ to process @code{1234} (unless you also have a file
+named @file{1234}; _GDBN__ does check for a core file first).
+
+@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__)
+_include__(gdbinv-m.m4)_dnl__
+_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
+
+_if__(!_GENERIC__)
+@node Mode Options, Mode Options, File Options, Starting _GDBN__
+_fi__(!_GENERIC__)
+_if__(_GENERIC__)
+@node Mode Options,  , File Options, Starting _GDBN__
+_fi__(_GENERIC__)
+@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
+Emacs sets this option when it 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__)
+_include__(gdbinv-s.m4)
+_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 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.  In some cases, 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}.  You can test abbreviations by using them as
+arguments to the @code{help} command.
+
+@cindex repeating commands  
+@kindex RET
+A blank line as input to _GDBN__ (typing just @key{RET}) means to
+repeat the previous command. Certain commands (for example, @code{run})
+will not repeat this way; these are commands for which unintentional
+repetition might cause trouble and which you are unlikely to want to
+repeat.
+
+The @code{list} and @code{x} commands, when you repeat them with
+@key{RET}, construct new arguments rather than repeating
+exactly as typed.  This permits easy scanning of source or memory.
+
+_GDBN__ can also use @key{RET} in another way: to partition lengthy
+output, in a way similar to the common utility @code{more}
+(@pxref{Screen Size}).  Since it's easy to press one @key{RET} too many
+in this situation, _GDBN__ disables command repetition after any command
+that generates this sort of display.
+
+@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 classes 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{class}
+Using one of the general help classes as an argument, you can get a
+list of the individual commands in that class.  For example, here is the
+help display for the class @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.  Each command supports 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.  
+
+@c @group
+@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
+@w{@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
+@c @end group
+
+Here are three miscellaneous @code{show} subcommands, all of which are
+exceptional in lacking corresponding @code{set} commands:
+
+@table @code
+@kindex show version
+@cindex version number
+@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__.  You
+must first specify the program name
+_if__(_VXWORKS__) 
+(except on VxWorks)
+_fi__(_VXWORKS__)
+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}.
+
+@cindex pipes
+@emph{Warning:} While input and output redirection work, you can't use
+pipes to pass the output of the program you're debugging to another
+program; if you attempt this, _GDBN__ is likely to wind up debugging the
+wrong program.
+@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, 
+using @code{set args} before the next @code{run} 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.  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 @r{[}@var{varname}@r{]}
+@kindex show environment
+Print the value of environment variable @var{varname} to be given to
+your program when it starts.  If you don't supply @var{varname}, 
+print the names and values of all environment variables to be given to
+your program.  You can abbreviate @code{environment} as @code{env}.
+
+@item set environment @var{varname} @r{[}=@r{]} @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
+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
+@cindex controlling terminal
+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 are 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}).
+
+@node Kill Process,  , Attach, Running
+@c @group
+@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.
+@c @end group
+
+On some operating systems, a program can't be executed outside _GDBN__
+while you have breakpoints set on it 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 while it 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
+
+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}.  You may then examine and change
+variables, set new breakpoints or remove old ones, and then continue
+execution.  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
+* Continuing and Stepping::     Resuming Execution
+* Signals::                     Signals
+@end menu
+
+@node Breakpoints, Continuing and 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 exception 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 like any other breakpoint: you enable, disable, and
+delete both breakpoints and watchpoints using 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---that is, if @var{cond} evaluates as true.
+@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 for 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
+@cindex regular expression
+Set breakpoints on all functions matching the regular expression
+@var{regex}.  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.
+
+When debugging C++ programs, @code{rbreak} is useful for setting
+breakpoints on overloaded functions that are not members of any special
+classes.
+
+@kindex info breakpoints
+@kindex $_
+@item info breakpoints @r{[}@var{n}@r{]}
+@item info break @r{[}@var{n}@r{]}
+Print 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 @var{n} 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 
+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 support watchpoint evaluation; 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.  You can
+use _GDBN__ 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++, exceptions are
+raised by calling a library function named @code{__raise_exception}
+which has the following ANSI C interface:
+
+@example
+    /* @var{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; 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 @r{[}breakpoints@r{]} @r{[}@var{bnums}@dots{}@r{]}
+@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 (_GDBN__
+asks confirmation, unless you've @code{set confirm off}).  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 set
+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 set
+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 @r{[}breakpoints@r{]} @r{[}@var{bnums}@dots{}@r{]}
+@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 @r{[}breakpoints@r{]} @r{[}@var{bnums}@dots{}@r{]}
+@kindex enable breakpoints
+@kindex enable
+Enable the specified breakpoints (or all defined breakpoints).  They
+become effective once again in stopping the program.
+
+@item enable @r{[}breakpoints@r{]} once @var{bnums}@dots{}
+Enable the specified breakpoints temporarily.  Each will be disabled
+again the next time it stops the program.
+
+@item enable @r{[}breakpoints@r{]} delete @var{bnums}@dots{}
+Enable the specified breakpoints to work once and then die.  Each of
+the breakpoints will be deleted the next time it stops the program.
+@end table
+
+Save for a breakpoint set with @code{tbreak} (@pxref{Set Breaks}),
+breakpoints that you set are initially enabled; subsequently, they become
+disabled or enabled only when you use one of the commands above.  (The
+command @code{until} can set and delete a breakpoint of its own, but it
+will not change the state of your other breakpoints;
+@pxref{Continuing and 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 @emph{true}.
+
+This is the converse of using assertions for program validation; in that
+situation, you want to stop when the assertion is violated---that is,
+when the condition is false.  In C, if you want to test an assertion expressed
+by the condition @var{assert}, you should set the condition 
+@samp{! @var{assert}} on the appropriate breakpoint.
+
+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,
+and specify a condition that tests whether the new value is an interesting
+one. 
+
+Break conditions ca have side effects, and may even call functions in
+your program.  This can be useful, for example, to activate functions
+that log program progress, or to use your own print functions to format
+special data structures. The 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 use @code{condition}, _GDBN__ checks @var{expression}
+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 @r{[}@var{bnum}@r{]}
+@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, type @code{commands} followed
+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 within a @var{command-list}.
+
+You can use breakpoint commands to start the program up again.  Simply
+use the @code{continue} command, or @code{step}, or any other command
+that resumes execution.  Subsequent commands in the command list are
+ignored.
+
+@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 meaningful only 
+at the beginning of a breakpoint command list.
+
+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 compensate for one bug so
+you can test for 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. 
+@c FIXME: revisit below when GNU sys avail.
+@c In the GNU system, this will be fixed by changing the behavior of
+@c terminal modes.
+
+Under Unix, you can get around this problem by writing actions into
+the breakpoint condition rather than in 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.  No input is lost here, because _GDBN__ evaluates break
+conditions  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 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__ offers you a menu of numbered choices for
+different possible breakpoints, and waits for your selection with the
+prompt @samp{>}.  The first two options are always @samp{[0] cancel}
+and @samp{[1] all}.  Typing @kbd{1} sets a breakpoint at each
+definition of @var{function}, and typing @kbd{0} aborts 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}.  
+We choose three particular definitions of that function name:
+
+@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 causes _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 Continuing and Stepping, Signals, Breakpoints, Stopping
+@section Continuing and Stepping
+
+@cindex stepping
+@cindex continuing
+@cindex resuming execution
+@dfn{Continuing} means resuming program execution until your program
+completes normally.  In contrast, @dfn{stepping} means resuming program
+execution for a very limited time: one line of source code, or one
+machine instruction.  Either when continuing or when stepping, the
+program may stop even sooner, due to a breakpoint or to a signal.  (If
+due to a signal, you may want to use @code{handle}, or use @samp{signal
+0} to resume execution; @pxref{Signals}.)
+
+@table @code
+@item continue @r{[}@var{ignore-count}@r{]}
+@kindex continue
+Resume program execution, at the address where the program last stopped;
+any breakpoints set at that address are bypassed.  The optional argument
+@var{ignore-count} allows you to specify a further number of times to
+ignore a breakpoint at this location; its effect is like that of
+@code{ignore} (@pxref{Conditions}).
+
+To resume execution at a different place, you can use @code{return}
+(@pxref{Returning}) to go back to the calling function; or @code{jump}
+(@pxref{Jumping}) to go to an arbitrary location in your program.
+
+@end table
+
+A typical technique for using stepping is to set 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 _GDBN__.  This command is
+abbreviated @code{s}.
+
+@quotation
+@emph{Warning:} If you use the @code{step} command while control is
+within a function that was compiled without debugging information,
+execution will proceed until control reaches another function.
+@end quotation
+
+@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 @r{[}@var{count}@r{]}
+@kindex next
+@kindex n
+Continue to the next source line in the current (innermost) 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 @var{count} is a repeat count, as for @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 function in the selected stack frame
+returns.  Print the returned value (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 machine code does not match the order of the source lines.  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
+
+This happened because, for execution efficiency, the compiler had
+generated code for the loop closure test at the end, rather than the
+start, of the loop---even though the test in a C @code{for}-loop is
+written before the body of the loop.  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 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
+
+
+@node Signals,  , Continuing and Stepping, 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
+
+@c @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
+@c @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.  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}.
+
+@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{C-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
+language that the source code corresponding to this frame was written in,
+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.  @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, Languages, 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 an expression of the language your
+program is written in (@pxref{Languages}).  You type
+
+@example
+print @var{exp}
+@end example
+
+@noindent
+where @var{exp} is an 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}.
+
+If you're interested in information about types, or about how the fields
+of a struct or class are declared, use the @code{ptype @var{exp}}
+command rather than @code{print}. @xref{Symbols}.
+
+@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.
+
+Because C is so widespread, most of the expressions shown in examples in
+this manual are in C.  @xref{Languages,, Using _GDBN__ with Different
+Languages}, for information on how to use expressions in other
+languages.  
+
+In this section, we discuss operators that you can use in _GDBN__
+expressions regardless of your programming language. 
+
+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.
+@c FIXME: casts supported---Mod2 true?
+
+_GDBN__ supports these operators 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++ scope 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++
+scope resolution operator in _GDBN__ expressions.
+
+@cindex wrong values
+@cindex variable values, wrong
+@quotation
+@emph{Warning:} Occasionally, a local variable may appear to have the
+wrong value at certain points in a function---just after entry to the
+function, and just before exit.  You may see this problem when you're
+stepping by machine instructions.  This is because on most machines, it
+takes more than one instruction to set up a stack frame (including local
+variable definitions); if you're stepping by machine instructions,
+variables may appear to have the wrong values until the stack frame is
+completely built.  On function exit, it usually also takes more than one
+machine instruction to destroy a stack frame; after you begin stepping
+through that group of instructions, local variable definitions may be
+gone.
+@end quotation
+
+@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.)
+
+Sometimes the artificial array mechanism isn't quite enough; in
+moderately complex data structures, the elements of interest may not
+actually be adjacent---for example, if you're interested in the values
+of pointers in an array.  One useful work-around in this situation is to
+use a convenience variable (@pxref{Convenience Vars}) as a counter in an
+expression that prints the first interesting value, and then repeat that
+expression via @key{RET}.  For instance, suppose you have an array
+@code{dtab} of pointers to structures, and you're interested in the
+values of a field @code{fv} in each structure.  Here's an example of
+what you might type:
+@example
+set $i = 0
+p dtab[$i++]->fv
+@key{RET}
+@key{RET}
+@dots{}
+@end example
+
+@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}.  @code{$_}'s type is @code{void *} except when set by the
+@code{x} command, in which case it is a pointer to the type of @code{$__}.
+
+@item $__
+The variable @code{$__} is automatically set by the @code{x} command
+to the value found in the last address examined.  Its type is chosen
+to match the format in which the data was printed.
+@end table
+
+@node Registers, Floating Point Hardware, Convenience Vars, Data
+@section Registers
+
+@cindex registers
+You can refer to machine register contents, 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 except floating-point
+registers (in the selected stack frame).
+
+@item info all-registers
+@kindex info all-registers
+@cindex floating point registers
+Print the names and values of all registers, including floating-point
+registers.
+
+@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 Languages, Symbols, Data, Top
+@chapter Using _GDBN__ with Different Languages
+@cindex languages
+
+Although programming languages generally have common aspects, they are
+rarely expressed in the same manner.  For instance, in ANSI C,
+dereferencing a pointer @code{p} is accomplished by @code{*p}, but in
+Modula-2, it is accomplished by @code{p^}.  Values can also be
+represented (and displayed) differently.  Hex numbers in C are written
+like @samp{0x1ae}, while in Modula-2 they appear as @samp{1AEH}.
+
+@cindex working language
+Language-specific information is built into _GDBN__ for some languages,
+allowing you to express operations like the above in the program's
+native language, and allowing _GDBN__ to output values in a manner
+consistent with the syntax of the program's native language.  The
+language you use to build expressions, called the @dfn{working
+language}, can be selected manually, or _GDBN__ can set it
+automatically.
+
+@menu
+* Setting::                     Switching between source languages
+* Show::                        Displaying the language
+* Checks::                      Type and Range checks
+* Support::                     Supported languages
+@end menu
+
+@node Setting, Show, Languages, Languages
+@section Switching between source languages
+
+There are two ways to control the working language---either have _GDBN__
+set it automatically, or select it manually yourself.  You can use the
+@code{set language} command for either purpose.  On startup, _GDBN__
+defaults to setting the language automatically.
+
+@menu
+* Manually::                    Setting the working language manually
+* Automatically::               Having _GDBN__ infer the source language
+@end menu
+
+@node Manually, Automatically, Setting, Setting
+@subsection Setting the working language
+
+@kindex set language
+To set the language, issue the command @samp{set language @var{lang}},
+where @var{lang} is the name of a language, such as @code{c} or
+@code{m2}, or the extension of a filename written in that language, such
+as @file{.c} or @file{.mod}.  For a list of the supported
+languages, type @samp{set language}.
+
+Setting the language manually prevents _GDBN__ from updating the working
+language automatically.  This can lead to confusion if you try
+to debug a program when the working language is not the same as the
+source language, when an expression is acceptable to both
+languages---but means different things.  For instance, if the current
+source file were written in C, and _GDBN__ was parsing Modula-2, a
+command such as:
+
+@example
+print a = b + c
+@end example
+
+@noindent
+might not have the effect you intended.  In C, this means to add
+@code{b} and @code{c} and place the result in @code{a}.  The result
+printed would be the value of @code{a}.  In Modula-2, this means to compare
+@code{a} to the result of @code{b+c}, yielding a @code{BOOLEAN} value.
+
+If you allow _GDBN__ to set the language automatically, then
+you can count on expressions evaluating the same way in your debugging
+session and in your program.
+
+@node Automatically,  , Manually, Setting
+@subsection Having _GDBN__ infer the source language
+
+To have _GDBN__ set the working language automatically, use @samp{set
+language local} or @samp{set language auto}.  _GDBN__ then infers the
+language that a program was written in by looking at the name of its
+source files, and examining their extensions:
+
+@table @file
+@item *.mod
+Modula-2 source file
+
+@item *.c
+@itemx *.cc
+C or C++ source file.
+@end table
+
+This information is recorded for each function or procedure in a source
+file.  When your program stops in a frame (usually by encountering a
+breakpoint), _GDBN__ sets the working language to the language recorded
+for the function in that frame.  If the language for a frame is unknown
+(that is, if the function or block corresponding to the frame was
+defined in a source file that does not have a recognized extension), the
+current working language is not changed, and _GDBN__ issues a warning.
+
+This may not seem necessary for most programs, which are written
+entirely in one source language.  However, program modules and libraries
+written in one source language can be used by a main program written in
+a different source language.  Using @samp{set language auto} in this
+case frees you from having to set the working language manually.
+
+@node Show, Checks, Setting, Languages
+@section Displaying the language
+
+The following commands will help you find out which language is the
+working language, and also what language source files were written in.
+
+@kindex show language
+@kindex info frame
+@kindex info source
+@table @code
+@item show language
+Display the current working language.  This is the
+language you can use with commands such as @code{print} to
+build and compute expressions that may involve variables in the program.
+
+@item info frame
+Among the other information listed here (@pxref{Frame Info,,Information
+about a Frame}) is the source language for this frame.  This is the
+language that will become the working language if you ever use an
+identifier that is in this frame.
+
+@item info source
+Among the other information listed here (@pxref{Symbols,,Examining the
+Symbol Table}) is the source language of this source file.
+
+@end table
+
+@node Checks, Support, Show, Languages
+@section Type and range Checking
+
+@quotation
+@emph{Warning:} In this release, the _GDBN__ commands for type and range
+checking are included, but they do not yet have any effect.  This
+section documents the intended facilities.
+@end quotation
+@c FIXME remove warning when type/range code added
+
+Some languages are designed to guard you against making seemingly common
+errors through a series of compile- and run-time checks.  These include
+checking the type of arguments to functions and operators, and making
+sure mathematical overflows are caught at run time.  Checks such as
+these help to ensure a program's correctness once it has been compiled
+by eliminating type mismatches, and providing active checks for range
+errors when the program is running.
+
+_GDBN__ can check for conditions like the above if you wish.
+Although _GDBN__ will not check the statements in your program, it
+can check expressions entered directly into _GDBN__ for evaluation via
+the @code{print} command, for example.  As with the working language,
+_GDBN__ can also decide whether or not to check automatically based on
+the source language of the program being debugged.
+@xref{Support,,Supported Languages}, for the default settings
+of supported languages.
+
+@menu
+* Type Checking::               An overview of type checking
+* Range Checking::              An overview of range checking
+@end menu
+
+@cindex type checking
+@cindex checks, type
+@node Type Checking, Range Checking, Checks, Checks
+@subsection An overview of type checking
+
+Some languages, such as Modula-2, are strongly typed, meaning that the
+arguments to operators and functions have to be of the correct type,
+otherwise an error occurs.  These checks prevent type mismatch
+errors from ever causing any run-time problems.  For example,
+
+@example
+1 + 2 @result{} 3
+@error{} 1 + 2.3
+@end example
+
+The second example fails because the @code{CARDINAL} 1 is not
+type-compatible with the @code{REAL} 2.3.
+
+For expressions you use in _GDBN__ commands, you can tell the _GDBN__
+type checker to skip checking; to treat any mismatches as errors and
+abandon the expression; or only issue warnings when type mismatches
+occur, but evaluate the expression anyway.  When you choose the last of
+these, _GDBN__ evaluates expressions like the second example above, but
+also issues a warning.
+
+Even though you may turn type checking off, other type-based reasons may
+prevent _GDBN__ from evaluating an expression.  For instance, _GDBN__ does not
+know how to add an @code{int} and a @code{struct foo}.  These particular
+type errors have nothing to do with the language in use, and usually
+arise from expressions, such as the one described above, which make
+little sense to evaluate anyway.
+
+Each language defines to what degree it is strict about type.  For
+instance, both Modula-2 and C require the arguments to arithmetical
+operators to be numbers.  In C, enumerated types and pointers can be
+represented as numbers, so that they are valid arguments to mathematical
+operators.  @xref{Support,,Supported Languages}, for futher
+details on specific languages.
+
+_GDBN__ provides some additional commands for controlling the type checker:
+
+@kindex set check
+@kindex set check type
+@kindex show check type
+@table @code
+@item set check type auto
+Set type checking on or off based on the current working language.  
+@xref{Support,,Supported Languages}, for the default settings for 
+each language.
+
+@item set check type on
+@itemx set check type off
+Set type checking on or off, overriding the default setting for the
+current working language.  Issue a warning if the setting does not
+match the language's default.  If any type mismatches occur in
+evaluating an expression while typechecking is on, _GDBN__ prints a
+message and aborts evaluation of the expression.
+
+@item set check type warn
+Cause the type checker to issue warnings, but to always attempt to
+evaluate the expression.  Evaluating the expression may still
+be impossible for other reasons.  For example, _GDBN__ cannot add
+numbers and structures.
+
+@item show type
+Show the current setting of the type checker, and whether or not _GDBN__ is 
+setting it automatically.
+@end table
+
+@cindex range checking
+@cindex checks, range
+@node Range Checking,  , Type Checking, Checks
+@subsection An overview of Range Checking
+
+In some languages (such as Modula-2), it is an error to exceed the
+bounds of a type; this is enforced with run-time checks.  Such range
+checking is meant to ensure program correctness by making sure
+computations do not overflow, or indices on an array element access do
+not exceed the bounds of the array.
+
+For expressions you use in _GDBN__ commands, you can tell _GDBN__ to
+ignore range errors; to always treat them as errors and abandon the
+expression; or to issue warnings when a range error occurs but evaluate
+the expression anyway.
+
+A range error can result from numerical overflow, from exceeding an
+array index bound, or when you type in a constant that is not a member
+of any type.  Some languages, however, do not treat overflows as an
+error.  In many implementations of C, mathematical overflow causes the
+result to ``wrap around'' to lower values---for example, if @var{m} is
+the largest integer value, and @var{s} is the smallest, then
+@example
+@var{m} + 1 @result{} @var{s}
+@end example
+
+This, too, is specific to individual languages, and in some cases
+specific to individual compilers or machines.  @xref{Support,,
+Supported Languages}, for further details on specific languages.
+
+_GDBN__ provides some additional commands for controlling the range checker:
+
+@kindex set check
+@kindex set check range
+@kindex show check range
+@table @code
+@item set check range auto
+Set range checking on or off based on the current working language.  
+@xref{Support,,Supported Languages}, for the default settings for 
+each language.
+
+@item set check range on
+@itemx set check range off
+Set range checking on or off, overriding the default setting for the
+current working language.  A warning is issued if the setting does not
+match the language's default.  If a range error occurs, then a message
+is printed and evaluation of the expression is aborted.
+
+@item set check range warn
+Output messages when the _GDBN__ range checker detects a range error,
+but attempt to evaluate the expression anyway.  Evaluating the
+expression may still be impossible for other reasons, such as accessing
+memory that the process does not own (a typical example from many UNIX
+systems).
+
+@item show range
+Show the current setting of the range checker, and whether or not it is 
+being set automatically by _GDBN__.
+@end table
+
+@node Support,  , Checks, Languages
+@section Supported Languages
+
+_GDBN__ 4.0 supports C, C++, and Modula-2.  The syntax for C and C++ is
+so closely related that _GDBN__ does not distinguish the two.  Some
+_GDBN__ features may be used in expressions regardless of the language
+you use: the _GDBN__ @code{@@} and @code{::} operators, and the
+@samp{@{type@}addr} construct (@pxref{Expressions}) can be used with the constructs of
+any of the supported languages.
+
+The following sections detail to what degree each of these
+source languages is supported by _GDBN__.  These sections are
+not meant to be language tutorials or references, but serve only as a
+reference guide to what the _GDBN__ expression parser will accept, and
+what input and output formats should look like for different languages.
+There are many good books written on each of these languages; please
+look to these for a language reference or tutorial.
+
+@menu
+* C::                           C and C++
+* Modula-2::                    Modula-2
+@end menu
+
+@node C, Modula-2, Support, Support
+@subsection C and C++
+@cindex C and C++
+
+@cindex expressions in C or C++
+Since C and C++ are so closely related, _GDBN__ does not distinguish
+between them when interpreting the expressions recognized in _GDBN__
+commands.  
+
+@cindex C++
+@kindex g++
+@cindex GNU C++
+The C++ debugging facilities are jointly implemented by the GNU C++
+compiler and _GDBN__.  Therefore, to debug your C++ code effectively,
+you must compile your C++ programs with the GNU C++ compiler,
+@code{g++}.
+
+
+@menu
+* C Operators::                 C and C++ Operators
+* C Constants::                 C and C++ Constants
+* Cplusplus expressions::       C++ Expressions
+* C Defaults::                  Default settings for C and C++
+* C Checks::                    C and C++ Type and Range Checks
+* Debugging C::                 _GDBN__ and C
+* Debugging C plus plus::       Special features for C++
+@end menu
+
+@cindex C and C++ operators
+@node C Operators, C Constants, C, C
+@subsubsection C and C++ Operators
+
+Operators must be defined on values of specific types.  For instance,
+@code{+} is defined on numbers, but not on structures.  Operators are
+often defined on groups of types.  For the purposes of C and C++, the
+following definitions hold:
+
+@itemize @bullet
+@item 
+@emph{Integral types} include @code{int} with any of its storage-class
+specifiers, @code{char}, and @code{enum}s.
+
+@item
+@emph{Floating-point types} include @code{float} and @code{double}.
+
+@item
+@emph{Pointer types} include all types defined as @code{(@var{type}
+*)}.
+
+@item 
+@emph{Scalar types} include all of the above.
+
+@end itemize
+
+@noindent
+The following operators are supported.  They are listed here
+in order of increasing precedence:
+
+@table @code
+_0__
+@item ,
+The comma or sequencing operator.  Expressions in a comma-separated list
+are evaluated from left to right, with the result of the entire
+expression being the last expression evaluated.
+
+@item =
+Assignment.  The value of an assignment expression is the value
+assigned.  Defined on scalar types.
+
+@item @var{op}=
+Used in an expression of the form @var{a} @var{op}@code{=} @var{b}, and
+translated to @var{a} @code{=} @var{a op b}.  @var{op}@code{=} and
+@code{=} have the same precendence.  @var{op} is any one of the
+operators @code{|}, @code{^}, @code{&}, @code{<<}, @code{>>}, @code{+},
+@code{-}, @code{*}, @code{/}, @code{%}.
+
+@item ?:
+The ternary operator.  @code{@var{a} ? @var{b} : @var{c}} can be thought
+of as:  if @var{a} then @var{b} else @var{c}.  @var{a} should be of an
+integral type.
+
+@item ||
+Logical OR.  Defined on integral types.
+
+@item &&
+Logical AND.  Defined on integral types.
+
+@item |
+Bitwise OR.  Defined on integral types.
+
+@item ^
+Bitwise exclusive-OR.  Defined on integral types.
+
+@item &
+Bitwise AND.  Defined on integral types.
+
+@item ==@r{, }!=
+Equality and inequality.  Defined on scalar types.  The value of these
+expressions is 0 for false and non-zero for true.
+
+@item <@r{, }>@r{, }<=@r{, }>=
+Less than, greater than, less than or equal, greater than or equal.
+Defined on scalar types.  The value of these expressions is 0 for false
+and non-zero for true.
+
+@item <<@r{, }>>
+left shift, and right shift.  Defined on integral types.
+
+@item @@ 
+The _GDBN__ ``artificial array'' operator (@pxref{Expressions}).
+
+@item +@r{, }-
+Addition and subtraction.  Defined on integral types, floating-point types and
+pointer types.  
+
+@item *@r{, }/@r{, }%
+Multiplication, division, and modulus.  Multiplication and division are
+defined on integral and floating-point types.  Modulus is defined on
+integral types.
+
+@item ++@r{, }--
+Increment and decrement.  When appearing before a variable, the
+operation is performed before the variable is used in an expression;
+when appearing after it, the variable's value is used before the
+operation takes place.
+
+@item *
+Pointer dereferencing.  Defined on pointer types.  Same precedence as
+@code{++}.
+
+@item &
+Address operator.  Defined on variables.  Same precedence as @code{++}.
+
+@item -
+Negative.  Defined on integral and floating-point types.  Same
+precedence as @code{++}.
+
+@item !
+Logical negation.  Defined on integral types.  Same precedence as
+@code{++}.
+
+@item ~
+Bitwise complement operator.  Defined on integral types.  Same precedence as
+@code{++}.
+
+@item .@r{, }->
+Structure member, and pointer-to-structure member.  For convenience,
+_GDBN__ regards the two as equivalent, choosing whether to dereference a
+pointer based on the stored type information.  
+Defined on @code{struct}s and @code{union}s.
+
+@item []
+Array indexing.  @code{@var{a}[@var{i}]} is defined as
+@code{*(@var{a}+@var{i})}.  Same precedence as @code{->}.
+
+@item ()
+Function parameter list.  Same precedence as @code{->}.
+
+@item ::
+C++ scope resolution operator.  Defined on
+@code{struct}, @code{union}, and @code{class} types.
+
+@item ::
+The _GDBN__ scope operator (@pxref{Expressions}).  Same precedence as
+@code{::}, above.  _1__
+@end table
+
+@cindex C and C++ constants
+@node C Constants, Cplusplus expressions, C Operators, C
+@subsubsection C and C++ Constants
+
+_GDBN__ allows you to express the constants of C and C++ in the
+following ways:
+
+@itemize @bullet
+
+@item
+Integer constants are a sequence of digits.  Octal constants are
+specified by a leading @samp{0} (ie. zero), and hexadecimal constants by
+a leading @samp{0x} or @samp{0X}.  Constants may also end with an
+@samp{l}, specifying that the constant should be treated as a
+@code{long} value.
+
+@item
+Floating point constants are a sequence of digits, followed by a decimal
+point, followed by a sequence of digits, and optionally followed by an
+exponent.  An exponent is of the form:
+@samp{@w{e@r{[[}+@r{]|}-@r{]}@var{nnn}}}, where @var{nnn} is another
+sequence of digits.  The @samp{+} is optional for positive exponents.
+
+@item
+Enumerated constants consist of enumerated identifiers, or their
+integral equivalents.
+
+@item
+Character constants are a single character surrounded by single quotes
+(@code{'}), or a number---the ordinal value of the corresponding character
+(usually its @sc{ASCII} value).  Within quotes, the single character may
+be represented by a letter or by @dfn{escape sequences}, which are of
+the form @samp{\@var{nnn}}, where @var{nnn} is the octal representation
+of the character's ordinal value; or of the form @samp{\@var{x}}, where
+@samp{@var{x}} is a predefined special character---for example,
+@samp{\n} for newline.
+
+@item
+String constants are a sequence of character constants surrounded
+by double quotes (@code{"}).
+
+@item
+Pointer constants are an integral value.
+
+@end itemize
+
+
+@node Cplusplus expressions, C Defaults, C Constants, C
+@subsubsection C++ Expressions
+
+@cindex expressions in C++
+_GDBN__'s expression handling has the following extensions to
+interpret a significant subset of C++ expressions:
+
+@enumerate
+
+@cindex member functions
+@item 
+Member function calls are allowed; you can use expressions like
+@example
+count = aml->GetOriginal(x, y)
+@end example
+
+@kindex this
+@cindex namespace in C++
+@item 
+While a member function is active (in the selected stack frame), your
+expressions have the same namespace available as the member function;
+that is, _GDBN__ allows implicit references to the class instance
+pointer @code{this} following the same rules as C++.
+
+@cindex call overloaded functions
+@cindex type conversions in C++
+@item 
+You can call overloaded functions; _GDBN__ will resolve the function
+call to the right definition, with one restriction---you must use
+arguments of the type required by the function that you want to call.
+_GDBN__ will not perform conversions requiring constructors or
+user-defined type operators.
+
+@cindex reference declarations
+@item
+_GDBN__ understands variables declared as C++ references; you can use them in
+expressions just as you do in C++ source---they are automatically
+dereferenced.  
+
+In the parameter list shown when _GDBN__ displays a frame, the values of
+reference variables are not displayed (unlike other variables); this
+avoids clutter, since references are often used for large structures.
+The @emph{address} of a reference variable is always shown, unless
+you've specified @samp{set print address off}.
+
+
+@item
+_GDBN__ supports the C++ name resolution operator @code{::}---your
+expressions can use it just as expressions in your program do.  Since
+one scope may be defined in another, you can use @code{::} repeatedly if
+necessary, for example in an expression like
+@samp{@var{scope1}::@var{scope2}::@var{name}}.  _GDBN__ also allows
+resolving name scope by reference to source files, in both C and C++
+debugging; @pxref{Variables}.
+
+@end enumerate
+
+
+@node C Defaults, C Checks, Cplusplus expressions, C
+@subsubsection C and C++ Defaults
+@cindex C and C++ defaults
+
+If you allow _GDBN__ to set type and range checking automatically, they 
+both default to @code{off} whenever the working language changes to 
+C/C++.  This happens regardless of whether you, or _GDBN__,
+selected the working language.
+
+If you allow _GDBN__ to set the language automatically, it sets the
+working language to C/C++ on entering code compiled from a source file
+whose name ends with @file{.c} or @file{.cc}.
+@xref{Automatically,,Having _GDBN__ infer the source language}, for
+further details.
+
+@node C Checks, Debugging C, C Defaults, C
+@subsubsection C and C++ Type and Range Checks
+@cindex C and C++ checks
+
+@quotation
+@emph{Warning:} in this release, _GDBN__ does not yet perform type or
+range checking.
+@end quotation
+@c FIXME remove warning when type/range checks added
+
+By default, when _GDBN__ parses C or C++ expressions, type checking
+is not used.  However, if you turn type checking on, _GDBN__ will
+consider two variables type equivalent if:
+
+@itemize @bullet
+@item
+The two variables are structured and have the same structure, union, or
+enumerated tag.
+
+@item 
+Two two variables have the same type name, or types that have been
+declared equivalent through @code{typedef}.
+
+@ignore
+@c leaving this out because neither J Gilmore nor R Pesch understand it.
+@c FIXME--beers?
+@item
+The two @code{struct}, @code{union}, or @code{enum} variables are
+declared in the same declaration.  (Note: this may not be true for all C
+compilers.)
+@end ignore
+
+@end itemize
+
+Range checking, if turned on, is done on mathematical operations.  Array
+indices are not checked, since they are often used to index a pointer
+that is not itself an array.
+
+@node Debugging C, Debugging C plus plus, C Checks, C
+@subsubsection _GDBN__ and C
+
+The @code{set print union} and @code{show print union} commands apply to
+the @code{union} type.  When set to @samp{on}, any @code{union} that is
+inside a @code{struct} or @code{class} will also be printed.
+Otherwise, it will appear as @samp{@{...@}}.
+
+The @code{@@} operator aids in the debugging of dynamic arrays, formed
+with pointers and a memory allocation function.  (@pxref{Expressions})
+
+@node Debugging C plus plus,  , Debugging C, C
+@subsubsection _GDBN__ Commands for C++
+
+@cindex commands for C++
+Some _GDBN__ commands are particularly useful with C++, and some are
+designed specifically for use with C++.  Here is a summary:
+
+@table @code
+@cindex break in overloaded functions
+@item @r{breakpoint menus}
+When you want a breakpoint in a function whose name is overloaded,
+_GDBN__'s breakpoint menus help you specify which function definition
+you want.  @xref{Breakpoint Menus}.
+
+@cindex overloading in C++
+@item rbreak @var{regex}
+Setting breakpoints using regular expressions is helpful for setting
+breakpoints on overloaded functions that are not members of any special
+classes. 
+@xref{Set Breaks}.
+
+@cindex C++ exception handling
+@item catch @var{exceptions}
+@itemx info catch
+Debug C++ exception handling using these commands.  @xref{Exception Handling}.
+
+@cindex inheritance 
+@item ptype @var{typename}
+Print inheritance relationships as well as other information for type
+@var{typename}. 
+@xref{Symbols}.
+
+@cindex C++ symbol display
+@item set print demangle
+@itemx show print demangle
+@itemx set print asm-demangle
+@itemx show print asm-demangle
+Control whether C++ symbols display in their source form, both when
+displaying code as C++ source and when displaying disassemblies.
+@xref{Print Settings}.
+
+@item set print object
+@itemx show print object
+Choose whether to print derived (actual) or declared types of objects. 
+@xref{Print Settings}.
+
+@item set print vtbl
+@itemx show print vtbl
+Control the format for printing virtual function tables.
+@xref{Print Settings}.
+
+@end table
+
+
+@node Modula-2,  , C, Support
+@subsection Modula-2
+@cindex Modula-2
+
+The extensions made to _GDBN__ to support Modula-2 support output
+from the GNU Modula-2 compiler (which is currently being developed).
+Other Modula-2 compilers are not currently supported, and attempting to
+debug executables produced by them will most likely result in an error
+as _GDBN__ reads in the executable's symbol table.
+
+@cindex expressions in Modula-2
+@menu
+* M2 Operators::                Built-in operators
+* Builtin Func/Proc::           Built-in Functions and Procedures
+* M2 Constants::                Modula-2 Constants
+* M2 Defaults::                 Default settings for Modula-2
+* Deviations::                  Deviations from standard Modula-2
+* M2 Checks::                   Modula-2 Type and Range Checks
+* M2 Scope::                    The scope operators @code{::} and @code{.}
+* GDB/M2::                      _GDBN__ and Modula-2
+@end menu
+
+@node M2 Operators, Builtin Func/Proc, Modula-2, Modula-2
+@subsubsection Operators
+@cindex Modula-2 operators
+
+Operators must be defined on values of specific types.  For instance,
+@code{+} is defined on numbers, but not on structures.  Operators are
+often defined on groups of types.  For the purposes of Modula-2, the
+following definitions hold:
+
+@itemize @bullet
+
+@item
+@emph{Integral types} consist of @code{INTEGER}, @code{CARDINAL}, and
+their subranges.
+
+@item
+@emph{Character types} consist of @code{CHAR} and its subranges.
+
+@item
+@emph{Floating-point types} consist of @code{REAL}.
+
+@item
+@emph{Pointer types} consist of anything declared as @code{POINTER TO
+@var{type}}.
+
+@item
+@emph{Scalar types} consist of all of the above.
+
+@item
+@emph{Set types} consist of @code{SET}s and @code{BITSET}s.
+
+@item
+@emph{Boolean types} consist of @code{BOOLEAN}.
+
+@end itemize
+
+@noindent
+The following operators are supported, and appear in order of
+increasing precedence:
+
+@table @code
+_0__
+@item ,
+Function argument or array index separator.
+
+@item :=
+Assignment.  The value of @var{var} @code{:=} @var{value} is
+@var{value}.
+
+@item <@r{, }>
+Less than, greater than on integral, floating-point, or enumerated
+types.
+
+@item <=@r{, }>=
+Less than, greater than, less than or equal to, greater than or equal to
+on integral, floating-point and enumerated types, or set inclusion on
+set types.  Same precedence as @code{<}.
+
+@item =@r{, }<>@r{, }#
+Equality and two ways of expressing inequality, valid on scalar types.
+Same precedence as @code{<}.  In _GDBN__ scripts, only @code{<>} is
+available for inequality, since @code{#} conflicts with the script
+comment character.
+
+@item IN
+Set membership.  Defined on set types and the types of their members.
+Same precedence as @code{<}.
+
+@item OR
+Boolean disjunction.  Defined on boolean types.
+
+@item AND@r{, }&
+Boolean conjuction.  Defined on boolean types.
+
+@item @@
+The _GDBN__ ``artificial array'' operator (@pxref{Expressions}).
+
+@item +@r{, }-
+Addition and subtraction on integral and floating-point types, or union
+and difference on set types.
+
+@item *
+Multiplication on integral and floating-point types, or set intersection
+on set types.
+
+@item /
+Division on floating-point types, or symmetric set difference on set
+types.  Same precedence as @code{*}.
+
+@item DIV@r{, }MOD
+Integer division and remainder.  Defined on integral types.  Same
+precedence as @code{*}.
+
+@item -
+Negative. Defined on @code{INTEGER}s and @code{REAL}s.
+
+@item ^
+Pointer dereferencing.  Defined on pointer types.  
+
+@item NOT
+Boolean negation.  Defined on boolean types.  Same precedence as
+@code{^}.
+
+@item .
+@code{RECORD} field selector.  Defined on @code{RECORD}s.  Same
+precedence as @code{^}.
+
+@item []
+Array indexing.  Defined on @code{ARRAY}s.  Same precedence as @code{^}.
+
+@item ()
+Procedure argument list.  Defined on @code{PROCEDURE}s.  Same precedence
+as @code{^}.
+
+@item ::@r{, }.
+_GDBN__ and Modula-2 scope operators.
+
+@end table
+
+@quotation
+@emph{Warning:} Sets and their operations are not yet supported, so _GDBN__
+will treat the use of the operator @code{IN}, or the use of operators
+@code{+}, @code{-}, @code{*}, @code{/}, @code{=}, , @code{<>}, @code{#},
+@code{<=}, and @code{>=} on sets as an error.
+@end quotation
+_1__
+
+@cindex Modula-2 builtins
+@node Builtin Func/Proc, M2 Constants, M2 Operators, Modula-2
+@subsubsection Built-in Functions and Procedures
+
+Modula-2 also makes available several built-in procedures and functions.
+In describing these, the following metavariables are used:
+
+@table @var
+
+@item a
+represents an @code{ARRAY} variable.
+
+@item c
+represents a @code{CHAR} constant or variable.
+
+@item i
+represents a variable or constant of integral type.
+
+@item m
+represents an identifier that belongs to a set.  Generally used in the
+same function with the metavariable @var{s}.  The type of @var{s} should
+be @code{SET OF @var{mtype}} (where @var{mtype} is the type of @var{m}.
+
+@item n
+represents a variable or constant of integral or floating-point type.
+
+@item r
+represents a variable or constant of floating-point type.
+
+@item t
+represents a type.
+
+@item v
+represents a variable.
+
+@item x
+represents a variable or constant of one of many types.  See the
+explanation of the function for details.
+
+@end table
+
+All Modula-2 built-in procedures also return a result, described below.
+
+@table @code
+@item ABS(@var{n})
+Returns the absolute value of @var{n}.
+
+@item CAP(@var{c})
+If @var{c} is a lower case letter, it returns its upper case
+equivalent, otherwise it returns its argument
+
+@item CHR(@var{i})
+Returns the character whose ordinal value is @var{i}.
+
+@item DEC(@var{v})
+Decrements the value in the variable @var{v}.  Returns the new value.
+
+@item DEC(@var{v},@var{i})
+Decrements the value in the variable @var{v} by @var{i}.  Returns the
+new value.
+
+@item EXCL(@var{m},@var{s})
+Removes the element @var{m} from the set @var{s}.  Returns the new
+set.
+
+@item FLOAT(@var{i})
+Returns the floating point equivalent of the integer @var{i}.
+
+@item HIGH(@var{a})
+Returns the index of the last member of @var{a}.
+
+@item INC(@var{v})
+Increments the value in the variable @var{v}.  Returns the new value.
+
+@item INC(@var{v},@var{i})
+Increments the value in the variable @var{v} by @var{i}.  Returns the
+new value.
+
+@item INCL(@var{m},@var{s})
+Adds the element @var{m} to the set @var{s} if it is not already
+there.  Returns the new set.
+
+@item MAX(@var{t})
+Returns the maximum value of the type @var{t}.
+
+@item MIN(@var{t})
+Returns the minimum value of the type @var{t}.
+
+@item ODD(@var{i})
+Returns boolean TRUE if @var{i} is an odd number.
+
+@item ORD(@var{x})
+Returns the ordinal value of its argument.  For example, the ordinal
+value of a character is its ASCII value (on machines supporting the
+ASCII character set).  @var{x} must be of an ordered type, which include
+integral, character and enumerated types.
+
+@item SIZE(@var{x})
+Returns the size of its argument.  @var{x} can be a variable or a type.
+
+@item TRUNC(@var{r})
+Returns the integral part of @var{r}.
+
+@item VAL(@var{t},@var{i})
+Returns the member of the type @var{t} whose ordinal value is @var{i}.
+@end table
+
+@quotation
+@emph{Warning:}  Sets and their operations are not yet supported, so
+_GDBN__ will treat the use of procedures @code{INCL} and @code{EXCL} as
+an error.
+@end quotation
+
+@cindex Modula-2 constants
+@node M2 Constants, M2 Defaults, Builtin Func/Proc, Modula-2
+@subsubsection Constants
+
+_GDBN__ allows you to express the constants of Modula-2 in the following
+ways:
+
+@itemize @bullet
+
+@item
+Integer constants are simply a sequence of digits.  When used in an
+expression, a constant is interpreted to be type-compatible with the
+rest of the expression.  Hexadecimal integers are specified by a
+trailing @samp{H}, and octal integers by a trailing @samp{B}.
+
+@item
+Floating point constants appear as a sequence of digits, followed by a
+decimal point and another sequence of digits.  An optional exponent can
+then be specified, in the form @samp{E@r{[}+@r{|}-@r{]}@var{nnn}}, where
+@samp{@r{[}+@r{|}-@r{]}@var{nnn}} is the desired exponent.  All of the
+digits of the floating point constant must be valid decimal (base 10)
+digits.
+
+@item
+Character constants consist of a single character enclosed by a pair of
+like quotes, either single (@code{'}) or double (@code{"}).  They may
+also be expressed by their ordinal value (their ASCII value, usually)
+followed by a @samp{C}.
+
+@item
+String constants consist of a sequence of characters enclosed by a pair
+of like quotes, either single (@code{'}) or double (@code{"}).  Escape
+sequences in the style of C are also allowed.  @xref{C Constants}, for a
+brief explanation of escape sequences.
+
+@item
+Enumerated constants consist of an enumerated identifier.
+
+@item
+Boolean constants consist of the identifiers @code{TRUE} and
+@code{FALSE}.
+
+@item
+Pointer constants consist of integral values only.
+
+@item
+Set constants are not yet supported.
+
+@end itemize
+
+@node M2 Defaults, Deviations, M2 Constants, Modula-2
+@subsubsection Modula-2 Defaults
+@cindex Modula-2 defaults
+
+If type and range checking are set automatically by _GDBN__, they 
+both default to @code{on} whenever the working language changes to 
+Modula-2.  This happens regardless of whether you, or _GDBN__,
+selected the working language.
+
+If you allow _GDBN__ to set the language automatically, then entering
+code compiled from a file whose name ends with @file{.mod} will set the
+working language to Modula-2. @xref{Automatically,,Having _GDBN__ set
+the language automatically}, for further details.
+
+@node Deviations, M2 Checks, M2 Defaults, Modula-2
+@subsubsection Deviations from Standard Modula-2
+@cindex Modula-2, deviations from
+
+A few changes have been made to make Modula-2 programs easier to debug.
+This is done primarily via loosening its type strictness:
+
+@itemize @bullet
+@item 
+Unlike in standard Modula-2, pointer constants can be formed by
+integers.  This allows you to modify pointer variables during
+debugging.  (In standard Modula-2, the actual address contained in a
+pointer variable is hidden from you; it can only be modified
+through direct assignment to another pointer variable or expression that
+returned a pointer.)
+
+@item 
+C escape sequences can be used in strings and characters to represent
+non-printable characters.  _GDBN__ will print out strings with these
+escape sequences embedded.  Single non-printable characters are
+printed using the @samp{CHR(@var{nnn})} format.
+
+@item
+The assignment operator (@code{:=}) returns the value of its right-hand
+argument.
+
+@item
+All builtin procedures both modify @emph{and} return their argument.
+
+@end itemize 
+
+@node M2 Checks, M2 Scope, Deviations, Modula-2
+@subsubsection Modula-2 Type and Range Checks
+@cindex Modula-2 checks
+
+@quotation
+@emph{Warning:} in this release, _GDBN__ does not yet perform type or
+range checking.
+@end quotation
+@c FIXME remove warning when type/range checks added
+
+_GDBN__ considers two Modula-2 variables type equivalent if:
+
+@itemize @bullet
+@item
+They are of types that have been declared equivalent via a @code{TYPE
+@var{t1} = @var{t2}} statement
+
+@item
+They have been declared on the same line.  (Note:  This is true of the
+GNU Modula-2 compiler, but it may not be true of other compilers.)
+
+@end itemize
+
+As long as type checking is enabled, any attempt to combine variables
+whose types are not equivalent is an error.
+
+Range checking is done on all mathematical operations, assignment, array
+index bounds, and all builtin functions and procedures.
+
+@node M2 Scope, GDB/M2, M2 Checks, Modula-2
+@subsubsection The scope operators @code{::} and @code{.}
+@cindex scope
+@kindex .
+@kindex ::
+
+There are a few subtle differences between the Modula-2 scope operator
+(@code{.}) and the _GDBN__ scope operator (@code{::}).  The two have
+similar syntax:
+
+@example
+
+@var{module} . @var{id}
+@var{scope} :: @var{id}
+
+@end example
+
+@noindent
+where @var{scope} is the name of a module or a procedure,
+@var{module} the name of a module, and @var{id} is any delcared
+identifier within the program, except another module.
+
+Using the @code{::} operator makes _GDBN__ search the scope
+specified by @var{scope} for the identifier @var{id}.  If it is not
+found in the specified scope, then _GDBN__ will search all scopes
+enclosing the one specified by @var{scope}.
+
+Using the @code{.} operator makes _GDBN__ search the current scope for
+the identifier specified by @var{id} that was imported from the
+definition module specified by @var{module}.  With this operator, it is
+an error if the identifier @var{id} was not imported from definition
+module @var{module}, or if @var{id} is not an identifier in
+@var{module}.
+
+@node GDB/M2,  , M2 Scope, Modula-2
+@subsubsection _GDBN__ and Modula-2
+
+Some _GDBN__ commands have little use when debugging Modula-2 programs.
+Five subcommands of @code{set print} and @code{show print} apply
+specifically to C and C++: @samp{vtbl}, @samp{demangle},
+@samp{asm-demangle}, @samp{object}, and @samp{union}.  The first four
+apply to C++, and the last to C's @code{union} type, which has no direct
+analogue in Modula-2.
+
+The @code{@@} operator (@pxref{Expressions}), while available
+while using any language, is not useful with Modula-2.  Its
+intent is to aid the debugging of @dfn{dynamic arrays}, which cannot be
+created in Modula-2 as they can in C or C++.  However, because an
+address can be specified by an integral constant, the construct
+@samp{@{@var{type}@}@var{adrexp}} is still useful.  (@pxref{Expressions})
+
+_0__
+@cindex @code{#} in Modula-2
+In _GDBN__ scripts, the Modula-2 inequality operator @code{#} is
+interpreted as the beginning of a comment.  Use @code{<>} instead.
+_1__
+
+
+@node Symbols, Altering, Languages, 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---and the language
+it was written in.
+
+@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: files whose symbols
+have already been read, and files whose symbols will be read when needed.
+
+@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 dump of debugging symbol data into the file
+@var{filename}.  Only symbols with debugging data are included.  _GDBN__
+includes all the symbols it already knows about: that is, @var{filename}
+reflects symbols for only those files whose symbols _GDBN__ has read.
+You can find out which files these are using the command @code{info
+files}.  The description of @code{symbol-file} describes how _GDBN__
+reads symbols; both commands are described under @ref{Files}.
+@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).  @xref{Languages}, for
+more information on operators in supported languages.
+
+@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{Continuing and 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.
+
+@node Signaling, Returning, Jumping, Altering
+@c @group
+@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
+@c @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{Continuing and
+Stepping}) resumes execution until the selected stack frame returns
+naturally.@refill
+
+@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 @var{filename}
+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 reading a symbol file, _GDBN__ will occasionally encounter
+problems, such as symbol types it does not recognize, or known bugs in
+compiler output.  By default, _GDBN__ does not notify you of such
+problems, since they're relatively common and primarily of interest to
+people debugging compilers.  If you are interested in seeing information
+about ill-constructed symbol tables, you can either ask _GDBN__ to print
+only one message about each such type of problem, no matter how many
+times the problem occurs; or you can ask _GDBN__ to print more messages,
+to see how many times the problems occur, 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.
+
+@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
+
+_GDBN__ 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
+_include__(gdbinv-m.m4)<>_dnl__
+@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__)
+@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. 
+_include__(gdbinv-s.m4)
+_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.
+@end table
+
+@node History, Screen Size, Editing, Controlling _GDBN__
+@section Command History
+@table @code
+@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
+
+@c @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.
+@c @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 2, 8, 10, 16.  @var{base} must itself be
+specified either unambiguously or using the current default radix; for
+example, any of
+
+@example
+set radix 1010
+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 is silent; but if you are debugging a compiler, you may find
+this information useful (@pxref{Symbol Errors}).  
+
+@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
+
+@c FIXME this doesn't really belong here.  But where *does* it belong?
+@cindex reloading symbols
+Some systems allow individual object files that make up your program to
+be replaced without stopping and restarting your program.
+_if__(_VXWORKS__)
+For example, in VxWorks you can simply recompile a defective object file
+and keep on running.
+_fi__(_VXWORKS__)
+If you're running on one of these systems, you can allow _GDBN__ to
+reload the symbols for automatically relinked modules:@refill
+@table @code
+@kindex set symbol-reloading
+@item set symbol-reloading on
+Replace symbol definitions for the corresponding source file when an
+object file with a particular name is seen again.
+
+@item set symbol-reloading off
+Don't replace symbol definitions when re-encountering object files of
+the same name.  This is the default state; if you're not running on a
+system that permits automatically relinking modules, you should leave
+@code{symbol-reloading} off, since otherwise _GDBN__ may discard symbols
+when linking large programs, that may contain several modules (from
+different directories or libraries) with the same name.
+
+@item show symbol-reloading
+Show the current @code{on} or @code{off} setting.
+@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 interacting
+with your program.  In particular, you can send signals the usual
+way---for example, @kbd{C-c C-c} for an interrupt, @kbd{C-c C-z} for a
+stop.
+
+@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 indicate 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
+@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 _GDBN__ 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 @samp{gnu.gdb.bug} 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
+Free Software Foundation
+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.texi
+@end iftex
+
+@node Renamed Commands, Installing _GDBN__, _GDBN__ Bugs, Top
+@appendix Renamed Commands
+
+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
+@example
+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 example
+@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
+
+_GDBN__ comes with a @code{configure} script that automates the process
+of preparing _GDBN__ for installation; you can then use @code{make} to
+build the @code{_GDBP__} program.
+
+The _GDBP__ distribution includes all the source code you need for
+_GDBP__ in a single directory @file{gdb-4.0}.  That directory in turn
+contains: 
+
+@table @code
+@item gdb-4.0/configure
+Overall script for configuring _GDBN__ and all its supporting libraries.
+
+@item gdb-4.0/gdb
+the source specific to _GDBN__ itself
+
+@item gdb-4.0/bfd
+source for the Binary File Descriptor Library
+
+@item gdb-4.0/include
+GNU include files
+
+@item gdb-4.0/libiberty
+source for the @samp{-liberty} free software library
+
+@item gdb-4.0/readline
+source for the GNU command-line interface
+@end table
+@noindent
+Each of these directories has its own @code{configure} script, which are
+used by the overall @code{configure} script in @file{gdb-4.0}.
+
+It is most convenient to run @code{configure} from the @file{gdb-4.0}
+directory.  The simplest way to configure and build _GDBN__ is the
+following:
+@example
+cd gdb-4.0
+./configure @var{host}
+make
+@end example
+@noindent
+where @var{host} is something like @samp{sun4} or @samp{decstation}, that
+identifies the platform where _GDBN__ will run.  This builds the three
+libraries @file{bfd}, @file{readline}, and @file{libiberty}, then
+@code{gdb} itself.  The configured source files, and the binaries, are
+left in the corresponding source directories.
+
+You can install @code{_GDBP__} anywhere; it has no hardwired paths.  However,
+you should make sure that the shell on your path (named by the
+@samp{SHELL} environment variable) is publicly readable; some systems
+refuse to let _GDBN__ debug child processes whose programs are not
+readable, and _GDBN__ uses the shell to start your program.
+
+@menu
+* Subdirectories::              Configuration subdirectories
+* Config Names::                Specifying names for hosts and targets
+* configure Options::           Summary of options for configure
+* Formatting Manual::           How to format and print _GDBN__ documentation
+@end menu
+
+
+@node Subdirectories, Config Names, Installing _GDBN__, Installing _GDBN__
+@section Configuration Subdirectories
+If you want to run _GDBN__ versions for several host or target machines,
+you'll need a different _GDBP__ compiled for each combination of host
+and target.  @code{configure} is designed to make this easy by allowing
+you to generate each configuration in a separate subdirectory.  If your
+@code{make} program handles the @samp{VPATH} feature (GNU @code{make}
+does), running @code{make} in each of these directories then builds the
+_GDBP__ program specified there.
+
+@code{configure} creates these subdirectories for you when you
+simultaneously specify several configurations; but it's a good habit
+even for a single configuration.  You can specify the use of
+subdirectories using the @samp{+subdirs} option (abbreviated
+@samp{+sub}).  For example, you can build _GDBN__ on a Sun 4 as follows:
+
+@example
+@group
+cd gdb-4.0
+./configure +sub sun4
+cd Host-sparc-sun-sunos4/Target-sparc-sun-sunos4
+make
+@end group
+@end example
+
+When @code{configure} uses subdirectories to build programs or
+libraries, it creates nested directories
+@file{Host-@var{host}/Target-@var{target}}.  (As you see in the example,
+the names used for @var{host} and @var{target} may be expanded from your
+@code{configure} argument; @pxref{Config Names}). @code{configure} uses
+these two directory levels because _GDBN__ can be configured for
+cross-compiling: _GDBN__ can run on one machine (the host) while
+debugging programs that run on another machine (the target).  You
+specify cross-debugging targets by giving the
+@samp{+target=@var{target}} option to @code{configure}.  Specifying only
+hosts still gives you two levels of subdirectory for each host, with the
+same configuration suffix on both; that is, if you give any number of
+hosts but no targets, _GDBN__ will be configured for native debugging on
+each host.  On the other hand, whenever you specify both hosts and
+targets on the same command line, @code{configure} creates all
+combinations of the hosts and targets you list.@refill
+
+When you run @code{make} to build a program or library, you must run it
+in a configured directory.  If you made a single configuration,
+without subdirectories, run @code{make} in the source directory.
+If you have @file{Host-@var{host}/Target-@var{target}} subdirectories,
+run @code{make} in those subdirectories.  
+
+Each @code{configure} and @code{Makefile} under each source directory
+runs recursively, so that typing @code{make} in @file{gdb-4.0} (or in a
+@file{gdb-4.0/Host-@var{host}/Target-@var{target}} subdirectory)
+builds all the required libraries, then _GDBN__.@refill
+
+If you run @code{configure} from a directory (such as @file{gdb-4.0}) that
+contains source directories for multiple libraries or programs,
+@code{configure} creates the @file{Host-@var{host}/Target-@var{target}}
+subdirectories in each library or program's source directory.  For
+example, typing:
+@example
+cd gdb-4.0
+configure sun4 +target=vxworks960
+@end example
+@noindent
+creates the following directories:
+@smallexample
+gdb-4.0/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
+gdb-4.0/bfd/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
+gdb-4.0/gdb/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
+gdb-4.0/libiberty/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
+gdb-4.0/readline/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
+@end smallexample
+@noindent
+The @code{Makefile} in
+@smallexample
+gdb-4.0/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
+@end smallexample
+@noindent
+will @code{cd} to the appropriate lower-level directories, for example:
+@smallexample
+gdb-4.0/bfd/Host-sparc-sun-sunos4/Target-i960-wrs-vxworks
+@end smallexample
+@noindent
+building each in turn.
+
+When you have multiple hosts or targets configured, you can run
+@code{make} on them in parallel (for example, if they are NFS-mounted on
+each of the hosts); they will not interfere with each other.
+
+@node Config Names, configure Options, Subdirectories, Installing _GDBN__
+@section Specifying Names for Hosts and Targets
+
+The specifications used for hosts and targets in the @code{configure}
+script are based on a three-part naming scheme, but some short predefined
+aliases are also supported.  The full naming scheme encodes three pieces
+of information in the following pattern: 
+@example
+@var{architecture}-@var{vendor}-@var{os}
+@end example
+
+For example, you can use the alias @code{sun4} as a @var{host} argument
+or in a @code{+target=}@var{target} option, but the full name of that
+configuration specifies that the architecture is @samp{sparc}, the
+vendor is @samp{sun}, and the operating system is @samp{sunos4}.
+
+@iftex
+@c I know this is ugly, but @group is useless except in examples now...
+@c (using texinfo 2.52 or so)
+@page
+@end iftex
+
+The following table shows all the architectures, hosts, and OS prefixes
+that @code{configure} recognizes in _GDBN__ 4.0.  Entries in the ``OS
+prefix'' column ending in a @samp{*} may be followed by a release number.
+
+@ifinfo
+@example
+
+ARCHITECTURE  VENDOR        OS prefix
+------------+-------------+-------------
+            |             |
+ a29k       | altos       | aix*
+ alliant    | aout        | aout
+ arm        | apollo      | bout
+ c1         | att         | bsd*
+ c2         | bout        | coff
+ i386       | coff        | ctix*
+ i860       | convergent  | dynix*
+ i960       | convex      | esix*
+ m68000     | dec         | hpux*
+ m68k       | encore      | isc*
+ m88k       | gould       | mach*
+ mips       | hp          | newsos*
+ ns32k      | ibm         | nindy*
+ pyramid    | intel       | none
+ rs6000     | isi         | osf*
+ rtpc       | little      | sco*    
+ sparc      | mips        | sunos*  
+ tahoe      | motorola    | sysv*   
+ tron       | ncr         | ultrix* 
+ vax        | next        | unos*   
+            | none        | v88r*   
+            | sco         | vms*    
+            | sequent     | vxworks*
+            | sgi         | 
+            | sony        |
+            | sun         |
+            | unicom      |
+            | utek        |
+            | wrs         |
+
+@end example
+@end ifinfo
+@tex
+\vskip \parskip\vskip \baselineskip
+\halign{\hskip\parindent\tt #\hfil &\qquad#&\tt #\hfil &\qquad#&\tt #\hfil\cr
+{\bf Architecture} &&{\bf Vendor} &&{\bf OS prefix}\cr
+\noalign{\hrule}
+\cr
+ a29k       &&altos       &&aix*\cr
+ alliant    &&aout        &&aout\cr
+ arm        &&apollo      &&bout\cr
+ c1         &&att         &&bsd*\cr
+ c2         &&bout        &&coff\cr
+ i386       &&coff        &&ctix*\cr
+ i860       &&convergent  &&dynix*\cr
+ i960       &&convex      &&esix*\cr
+ m68000     &&dec         &&hpux*\cr
+ m68k       &&encore      &&isc*\cr
+ m88k       &&gould       &&mach*\cr
+ mips       &&hp          &&newsos*\cr
+ ns32k      &&ibm         &&nindy*\cr
+ pyramid    &&intel       &&none\cr
+ rs6000     &&isi         &&osf*\cr
+ rtpc       &&little      &&sco*\cr      
+ sparc      &&mips        &&sunos*\cr    
+ tahoe      &&motorola    &&sysv*\cr     
+ tron       &&ncr         &&ultrix*\cr   
+ vax        &&next        &&unos*\cr     
+            &&none        &&v88r*\cr     
+            &&sco         &&vms*\cr      
+            &&sequent     &&vxworks*\cr  
+            &&sgi         \cr            
+            &&sony        \cr            
+            &&sun         \cr            
+            &&unicom      \cr            
+            &&utek        \cr            
+            &&wrs         \cr
+}
+@end tex
+@quotation
+@emph{Warning:} Many combinations of architecture, vendor, and OS are
+untested. 
+@end quotation
+
+The @code{configure} script accompanying _GDBN__ 4.0 does not provide
+any query facility to list all supported host and target names or
+aliases.  @code{configure} calls the Bourne shell script
+@code{config.sub} to map abbreviations to full names; you can read the
+script, if you wish, or you can use it to test your guesses on
+abbreviations---for example:
+@example
+% sh config.sub sun4
+sparc-sun-sunos4
+% sh config.sub sun3
+m68k-sun-sunos4
+% sh config.sub decstation
+mips-dec-ultrix
+% sh config.sub hp300bsd
+m68k-hp-bsd
+% sh config.sub i386v
+i386-none-sysv
+% sh config.sub i486v
+*** No vendor: configuration `i486v' not recognized
+@end example
+
+@node configure Options, Formatting Manual, Config Names, Installing _GDBN__
+@section @code{configure} Options
+
+Here is a summary of all the @code{configure} options and arguments that
+you might use for building _GDBN__:
+
+@example
+configure @r{[}+destdir=@var{dir}@r{]} @r{[}+subdirs@r{]} @r{[}+norecur@r{]} @r{[}+rm@r{]}
+          @r{[}+target=@var{target}@dots{}@r{]} @var{host}@dots{}
+@end example
+@noindent
+You may introduce options with the character @samp{-} rather than
+@samp{+} if you prefer; but you may abbreviate option names if you use
+@samp{+}.
+
+@table @code
+@item +destdir=@var{dir}
+@var{dir} is an installation directory @emph{path prefix}.  After you
+configure with this option, @code{make install} will install _GDBN__ as
+@file{@var{dir}/bin/_GDBP__}, and the libraries in @file{@var{dir}/lib}.
+If you specify @samp{+destdir=/usr/local}, for example, @code{make
+install} creates @file{/usr/local/bin/gdb}.@refill
+
+@item +subdirs
+Write configuration specific files in subdirectories of the form
+@example
+Host-@var{host}/Target-@var{target}
+@end example
+@noindent
+(and configure the @code{Makefile} to write binaries there too).
+Without this option, if you specify only one configuration for _GDBN__,
+@code{configure} will use the same directory for source, configured
+files, and binaries.  This option is used automatically if you specify
+more than one @var{host} or more than one @samp{+target=@var{target}}
+option on the @code{configure} command line.
+
+@item +norecur
+Configure only the directory where @code{configure} is executed; do not
+propagate configuration to subdirectories.
+
+@item +rm
+Remove the configuration that the other arguments specify.
+
+@item +parse=@var{lang} @dots{}
+Configure the _GDBN__ expression parser to parse the listed languages.
+@samp{all} configures _GDBN__ for all supported languages.  To get a
+list of all supported languages, omit the argument.  Without this
+option, _GDBN__ is configured to parse all supported languages.
+
+@item +target=@var{target} @dots{}
+Configure _GDBN__ for cross-debugging programs running on each specified
+@var{target}.  You may specify as many @samp{+target} options as you
+wish.  Without this option, _GDBN__ is configured to debug programs that
+run on the same machine (@var{host}) as _GDBN__ itself.
+
+There is no convenient way to generate a list of all available targets.
+
+@item @var{host} @dots{}
+Configure _GDBN__ to run on each specified @var{host}.  You may specify as
+many host names as you wish.  
+
+There is no convenient way to generate a list of all available hosts.
+@end table
+
+@noindent
+@code{configure} accepts other options, for compatibility with
+configuring other GNU tools recursively; but these are the only
+options that affect _GDBN__ or its supporting libraries.
+
+@node Formatting Manual,  , configure Options, Installing _GDBN__
+@section Formatting this Manual
+
+The _GDBN__ 4.0 release includes the Info version of this manual already
+formatted: the main Info file is @file{gdb-4.0/gdb/gdb.info}, and it
+refers to subordinate files matching @samp{gdb.info*} in the same
+directory.
+
+If you want to make these Info files yourself from the _GDBN__ manual's
+source, you need the GNU @code{makeinfo} program.  Once you have it, you
+can type
+@example
+cd gdb-4.0/gdb
+make gdb.info
+@end example
+@noindent
+to make the Info file.
+
+If you want to format and print copies of this manual, you need several
+things: 
+@itemize @bullet
+@item 
+@TeX{}, the public domain typesetting program written by Donald Knuth,
+must be installed on your system and available through your execution
+path.
+@item 
+@file{gdb-4.0/texinfo}: @TeX{} macros defining the GNU
+Documentation Format.
+@item
+@emph{A @sc{dvi} output program.}  @TeX{} doesn't actually make marks on
+paper; it produces output files called @sc{dvi} files.  If your system
+has @TeX{} installed, chances are it has a program for printing out
+these files; one popular example is @code{dvips}, which can print
+@sc{dvi} files on PostScript printers.
+@end itemize
+@noindent
+Once you have these things, you can type
+@example
+cd gdb-4.0/gdb
+make gdb.dvi
+@end example
+@noindent
+to format the text of this manual, and print it with the usual output
+method for @TeX{} @sc{dvi} files at your site.
+
+@cindex _GDBN__ reference card
+@cindex reference card
+You might also want hard copy of the _GDBN__ reference card.  The
+_GDBN__ 4.0 release includes an already-formatted reference card, ready
+for printing on a PostScript printer, as @file{gdb-4.0/gdb/refcard.ps}.
+It uses the most common PostScript fonts: the Times family, Courier, and
+Symbol.  If you have a PostScript printer you can print the reference
+card by just sending @file{refcard.ps} to the printer.
+
+If you have some other kind of printer, or want to print using Computer
+Modern fonts instead, you can still print the reference card if you have
+@TeX{}.  Format the reference card by typing
+@example
+cd gdb-4.0/gdb
+make refcard.dvi
+@end example
+@noindent
+
+The _GDBN__ reference card is designed to print in landscape mode on US
+``letter'' size paper; that is, on a sheet 11 inches wide by 8.5 inches
+high.  You will need to specify this form of printing as an option to
+your @sc{dvi} output program.
+
+
+@node Copying, Index, Installing _GDBN__, Top
+@unnumbered GNU GENERAL PUBLIC LICENSE
+@center Version 2, June 1991
+
+@display
+Copyright @copyright{} 1989, 1991 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 licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU 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.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), 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 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 show them these terms so they know 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.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+@iftex
+@unnumberedsec TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+@end iftex
+@ifinfo
+@center TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+@end ifinfo
+
+@enumerate
+@item
+This License 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 derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term ``modification''.)  Each licensee is addressed as ``you''.
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+@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 License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+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.
+
+@item
+You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+@alphaenumerate
+@item
+You must cause the modified files to carry prominent notices
+stating that you changed the files and the date of any change.
+
+@item
+You must cause any work that you distribute or publish, that in
+whole or in part contains or is derived from the Program or any
+part thereof, to be licensed as a whole at no charge to all third
+parties under the terms of this License.
+
+@item
+If the modified program normally reads commands interactively
+when run, you must cause it, when started running for such
+interactive use in the most ordinary 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
+License.  (Exception: if the Program itself is interactive but
+does not normally print such an announcement, your work based on
+the Program is not required to print an announcement.)
+@end alphaenumerate
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+@item
+You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+@alphaenumerate
+@item
+Accompany it with the complete corresponding machine-readable
+source code, which must be distributed under the terms of Sections
+1 and 2 above on a medium customarily used for software interchange; or,
+
+@item
+Accompany it with a written offer, valid for at least three
+years, to give any third party, for a charge no more than your
+cost of physically performing source distribution, a complete
+machine-readable copy of the corresponding source code, to be
+distributed under the terms of Sections 1 and 2 above on a medium
+customarily used for software interchange; or,
+
+@item
+Accompany it with the information you received as to the offer
+to distribute corresponding source code.  (This alternative is
+allowed only for noncommercial distribution and only if you
+received the program in object code or executable form with such
+an offer, in accord with Subsection b above.)
+@end alphaenumerate
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+@item
+You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+@item
+You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing 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 for copying, distributing or modifying
+the Program or works based on it.
+
+@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.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+@item
+If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+@item
+If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+@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 this 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
+this 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 the public, 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 2 of the License, 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 @samp{show w} and @samp{show c} should show
+the appropriate parts of the General Public License.  Of course, the
+commands you use may be called something other than @samp{show w} and
+@samp{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:
+
+@example
+Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+`Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+@var{signature of Ty Coon}, 1 April 1989
+Ty Coon, President of Vice
+@end example
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.
+
+
+@node Index,  , Copying, Top
+@unnumbered Index
+
+@printindex cp
+
+@tex
+% I think something like @colophon should be in texinfo.  In the
+% meantime:
+\long\def\colophon{\hbox to0pt{}\vfill
+\centerline{The body of this manual is set in}
+\centerline{\fontname\tenrm,}
+\centerline{with headings in {\bf\fontname\tenbf}}
+\centerline{and examples in {\tt\fontname\tentt}.}
+\centerline{{\it\fontname\tenit\/} and}
+\centerline{{\sl\fontname\tensl\/}}
+\centerline{are used for emphasis.}\vfill}
+\page\colophon
+% Blame: pesch@cygnus.com, 28mar91.
+@end tex
+
+@contents
+@bye
diff --git a/gdb/doc/interim-gdbinv-m.m4 b/gdb/doc/interim-gdbinv-m.m4
new file mode 100755
index 0000000..8fe5f91
--- /dev/null
+++ b/gdb/doc/interim-gdbinv-m.m4
@@ -0,0 +1,13 @@
+_dnl__								-*- Texinfo -*-
+_dnl__ Copyright (c) 1991 Free Software Foundation, Inc.
+_dnl__ This file is part of the source for the GDB manual.
+_dnl__ M4 FRAGMENT: $Id$
+_if__(_I960__)
+* i960-Nindy Remote::		_GDBN__ with a Remote i960 (Nindy)
+_fi__(_I960__)
+_if__(_AMD29K__)
+* EB29K Remote::		_GDBN__ with a Remote EB29K
+_fi__(_AMD29K__)
+_if__(_VXWORKS__)
+* VxWorks Remote::		_GDBN__ and VxWorks
+_fi__(_VXWORKS__)
diff --git a/gdb/doc/interim-gdbinv-s.m4 b/gdb/doc/interim-gdbinv-s.m4
new file mode 100755
index 0000000..82de97a
--- /dev/null
+++ b/gdb/doc/interim-gdbinv-s.m4
@@ -0,0 +1,427 @@
+_dnl__								-*- Texinfo -*-
+_dnl__ Copyright (c) 1990 1991 Free Software Foundation, Inc.
+_dnl__ This file is part of the source for the GDB manual.
+@c M4 FRAGMENT $Id$
+@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).
+_if__(_I960__)
+_if__(!_GENERIC__)
+@node i960-Nindy Remote, EB29K Remote, Mode Options, Starting _GDBN__
+_fi__(!_GENERIC__)
+_if__(_GENERIC__)
+@node i960-Nindy Remote, EB29K Remote, Remote, Remote
+_fi__(_GENERIC__)
+@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. 
+
+@node Nindy reset,  , Nindy Options, i960-Nindy Remote
+@c @group
+@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
+@c @end group
+_fi__(_I960__)
+
+_if__(_AMD29K__)
+_if__(!_GENERIC__)
+@node EB29K Remote, VxWorks Remote, i960-Nindy Remote, Starting _GDBN__
+_fi__(!_GENERIC__)
+_if__(_GENERIC__)
+@node EB29K Remote, VxWorks Remote, i960-Nindy Remote, Remote
+_fi__(_GENERIC__)
+@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__)
+_if__(!_GENERIC__)
+@node VxWorks Remote,  , EB29K Remote, Starting _GDBN__
+_fi__(!_GENERIC__)
+_if__(_GENERIC__)
+@node VxWorks Remote,  , EB29K Remote, Remote
+_fi__(_GENERIC__)
+@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__)