_dnl__ -*-Texinfo-*-
_dnl__ Copyright (c) 1988 1989 1990 1991 Free Software Foundation, Inc.
-_dnl__ This file controls overall layout of the GDB manual.
\input texinfo
@setfilename _GDBP__.info
@c $Id$
_0__
m4 pretex.m4 none.m4 m680x0.m4 gdb.texinfo >gdb-680x0.texinfo
_1__
-will produce (assuming your path finds either GNU or SysV m4; Berkeley
-won't do) a file suitable for formatting. See the text in "pretex.m4"
-for a fuller explanation (and the macro definitions).
+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
-_include__(gdb.top-m4)
-_include__(gdb.sample-m4)
-_include__(gdb.invoc-m4)
-_include__(gdb.cmds-m4)
-_include__(gdb.run-m4)
-_include__(gdb.stop-m4)
-_include__(gdb.stack-m4)
-_include__(gdb.src-m4)
-_include__(gdb.data-m4)
-_include__(gdb.symb-m4)
-_include__(gdb.alter-m4)
-_include__(gdb.files-m4)
-_include__(gdb.tgts-m4)
-_include__(gdb.ctl-m4)
-_include__(gdb.canned-m4)
-_include__(gdb.emacs-m4)
-_include__(gdb.bugs-m4)
-_include__(gdb.rdln-m4)
-_include__(gdb.rename-m4)
-_include__(gdb.install-m4)
-_include__(gdb.gpl-m4)
+@c
+@syncodeindex ky cp
+@c FOR UPDATES LEADING TO THIS DRAFT, GDB CHANGELOG CONSULTED BETWEEN:
+@c Sun May 19 05:36:59 1991 John Gilmore (gnu at cygint.cygnus.com)
+@c Sat Dec 22 02:51:40 1990 John Gilmore (gnu at cygint)
+@ifinfo
+This file documents the GNU debugger _GDBN__.
+
+Copyright (C) 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
+
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+
+@ignore
+Permission is granted to process this file through TeX and print the
+results, provided the printed document carries copying permission
+notice identical to this one except for the removal of this paragraph
+(this paragraph not being relevant to the printed manual).
+
+@end ignore
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+section entitled ``GNU General Public License'' is included exactly as
+in the original, and provided that the entire resulting derived work is
+distributed under the terms of a permission notice identical to this
+one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the section entitled ``GNU General Public License'' may be
+included in a translation approved by the Free Software Foundation
+instead of in the original English.
+@end ifinfo
+@smallbook
+@setchapternewpage odd
+_if__(_GENERIC__)
+@settitle Using _GDBN__ (v4.0)
+_fi__(_GENERIC__)
+_if__(!_GENERIC__)
+@settitle Using _GDBN__ v4.0 (_HOST__)
+_fi__(!_GENERIC__)
+@iftex
+@finalout
+@end iftex
+@titlepage
+@title{Using _GDBN__}
+@subtitle{A Guide to the GNU Source-Level Debugger}
+_if__(!_GENERIC__)
+@subtitle{On _HOST__ Systems}
+_fi__(!_GENERIC__)
+@sp 1
+@c Maybe crank this up to "Fourth Edition" when released at FSF
+@c @subtitle Third Edition---_GDBN__ version 4.0
+@subtitle _GDBN__ version 4.0
+@subtitle May 1991
+@author{Richard M. Stallman@qquad @hfill Free Software Foundation}
+@author{Roland H. Pesch@qquad @hfill Cygnus Support}
+@page
+@tex
+{\parskip=0pt
+\hfill rms\@ai.mit.edu, pesch\@cygnus.com\par
+\hfill {\it Using _GDBN__}, \manvers\par
+\hfill \TeX{}info \texinfoversion\par
+}
+@end tex
+
+@vskip 0pt plus 1filll
+Copyright @copyright{} 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
+
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided also that the
+section entitled ``GNU General Public License'' is included exactly as
+in the original, and provided that the entire resulting derived work is
+distributed under the terms of a permission notice identical to this
+one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that the section entitled ``GNU General Public License'' may be
+included in a translation approved by the Free Software Foundation
+instead of in the original English.
+@end titlepage
+@page
+
+@node Top, Summary, (dir), (dir)
+@ifinfo
+This file describes version 4.0 of GDB, the GNU symbolic debugger.
+@end ifinfo
+
+@menu
+* Summary:: Summary of _GDBN__
+* New Features:: New Features in _GDBN__ version 4.0
+* Sample Session:: A Sample _GDBN__ Session
+* Invocation:: Getting In and Out of _GDBN__
+* Commands::
+* Running:: Running Programs Under _GDBN__
+* Stopping:: Stopping and Continuing
+* Stack:: Examining the Stack
+* Source:: Examining Source Files
+* Data:: Examining Data
+* Symbols:: Examining the Symbol Table
+* Altering:: Altering Execution
+* _GDBN__ Files::
+* Targets:: Specifying a Debugging Target
+* Controlling _GDBN__:: Controlling _GDBN__
+* Sequences:: Canned Sequences of Commands
+* Emacs:: Using _GDBN__ under GNU Emacs
+* _GDBN__ Bugs:: Reporting Bugs in _GDBN__
+* Renamed Commands::
+* Installing _GDBN__:: Installing _GDBN__
+* Copying:: GNU GENERAL PUBLIC LICENSE
+* Index:: Index
+ --- 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
+* Stepping:: Stepping
+* Continuing:: Continuing
+* 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::
+
+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
+
+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::
+* EB29K Remote::
+* VxWorks Remote::
+
+_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
+@end menu
+
+@node Summary, New Features, Top, Top
+@unnumbered Summary of _GDBN__
+
+The purpose of a debugger such as _GDBN__ is to allow you to see what is
+going on ``inside'' another program while it executes---or what another
+program was doing at the moment it crashed.
+
+_GDBN__ can do four main kinds of things (plus other things in support of
+these) to help you catch bugs in the act:
+
+@itemize @bullet
+@item
+Start your program, specifying anything that might affect its behavior.
+
+@item
+Make your program stop on specified conditions.
+
+@item
+Examine what has happened, when your program has stopped.
+
+@item
+Change things in your program, so you can experiment with correcting the
+effects of one bug and go on to learn about another.
+@end itemize
+
+_GDBN__ can be used to debug programs written in C and C++. Pascal support
+is being implemented, and Fortran support will be added when a GNU
+Fortran compiler is ready.
+
+@menu
+* Free Software:: Free Software
+* Contributors:: Contributors to GDB
+@end menu
+
+@node Free Software, Contributors, Summary, Summary
+@unnumberedsec Free Software
+_GDBN__ is @dfn{free software}, protected by the GNU General Public License (GPL).
+The GPL gives you the freedom to copy or adapt a licensed
+program---but every person getting a copy also gets with it the
+freedom to modify that copy (which means that they must get access to
+the source code), and the freedom to distribute further copies.
+Typical software companies use copyrights to limit your freedoms; the
+Free Software Foundation uses the GPL to preserve these freedoms.
+
+Fundamentally, the General Public License is a license which says that
+you have these freedoms and that you can't take these freedoms away
+from anyone else.
+
+@c FIXME: (passim) go through all xrefs, expanding to use text headings
+For full details, @pxref{Copying}.
+@node Contributors, , Free Software, Summary
+@unnumberedsec Contributors to GDB
+
+Richard Stallman was the original author of GDB, 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 (release 4.0); Jim Kingdon (releases 3.9, 3.5, 3.4, 3.3);
+and Randy Smith (releases 3.2, 3.1, 3.0). As major maintainer of GDB
+for some period, each contributed significantly to the structure,
+stability, and capabilities of the entire debugger.
+
+Richard Stallman, assisted at various times by Pete TerMaat, Chris
+Hanson, and Richard Mlynarik, handled releases through 2.8.
+
+Michael Tiemann is the author of most of the GNU C++ support in GDB,
+with significant additional contributions from Per Bothner. James
+Clark wrote the GNU C++ demangler. Early work on C++ was by Peter
+TerMaat (who also did much general update work leading to release 3.0).
+
+GDB 4.0 uses the BFD subroutine library to examine multiple
+object-file formats; BFD was a joint project of V. Gumby
+Henkel-Wallace, Rich Pixley, Steve Chamberlain, and John Gilmore.
+
+David Johnson wrote the original COFF support; Pace Willison did
+the original support for encapsulated COFF.
+
+Adam de Boor and Bradley Davis contributed the ISI Optimum V support.
+Per Bothner, Noboyuki Hikichi, and Alessandro Forin contributed MIPS
+support. Jean-Daniel Fekete contributed Sun 386i support. Chris
+Hanson improved the HP9000 support. Noboyuki Hikichi and Tomoyuki
+Hasei contributed Sony/News OS 3 support. David Johnson contributed
+Encore Umax support. Jyrki Kuoppala contributed Altos 3068 support.
+Keith Packard contributed NS32K support. Doug Rabson contributed
+Acorn Risc Machine support. Chris Smith contributed Convex support
+(and Fortran debugging). Jonathan Stone contributed Pyramid support.
+Michael Tiemann contributed SPARC support. Tim Tucker contributed
+support for the Gould NP1 and Gould Powernode. Pace Willison
+contributed Intel 386 support. Jay Vosburgh contributed Symmetry
+support.
+
+Rich Schaefer helped with support of SunOS shared libraries.
+
+Jay Fenlason and Roland McGrath ensured that GDB and GAS agree about
+several machine instruction sets.
+
+Patrick Duval, Ted Goldstein, Vikram Koka and Glenn Engel helped
+develop remote debugging. Intel Corporation and Wind River Systems
+contributed remote debugging modules for their products.
+
+Brian Fox is the author of the readline libraries providing
+command-line editing and command history.
+
+@node New Features, Sample Session, Summary, Top
+@unnumbered New Features since _GDBN__ version 3.5
+
+@table @emph
+@item Targets
+Using the new command @code{target}, you can select at runtime whether
+you are debugging local files, local processes, standalone systems over
+a serial port, realtime systems over a TCP/IP connection, etc.
+Internally, _GDBN__ now uses a function vector to mediate access to
+different targets; if you need to add your own support for a remote
+protocol, this makes it much easier.
+
+@item Watchpoints
+_GDBN__ now sports watchpoints as well as breakpoints. You can use a
+watchpoint to stop execution whenever the value of an expression
+changes, without having to predict a particular place in your program
+where this may happen.
+
+@item Object Code Formats
+_GDBN__ uses a new scheme called Binary File Descriptors (BFD) to permit
+it to switch dynamically, without reconfiguration or recompilation,
+between different object-file formats. Formats currently supported are
+COFF, a.out, and the Intel 960 b.out; files may be read as .o's, archive
+libraries, or core dumps. BFD is available as a subroutine library so
+that other programs may take advantage of it, and the other GNU binary
+utilities are being converted to use it.
+
+@item Configuration
+Compile-time configuration (to select a particular architecture and
+operating system) is much easier. The script @code{config.gdb} now
+handles specification of separate host and target configurations.
+
+@item Interaction
+The user interface to _GDBN__'s control variables has been simplified
+and consolidated in two commands, @code{set} and @code{show}. Output
+lines are now broken at readable places, rather than overflowing onto
+the next line. You can suppress output of machine-level addresses,
+displaying only source language information.
+
+
+@item Source Language
+_GDBN__ now has limited support for C++ exception handling: _GDBN__ can
+break when an exception is raised, before the stack is peeled back to
+the exception handler's context.
+
+@item Command Rationalization
+Many _GDBN__ commands have been renamed to make them easier to remember
+and use. In particular, the subcommands of @code{info} and
+@code{show}/@code{set} are grouped to make the former refer to the state
+of your program, and the latter refer to the state of _GDBN__ itself.
+@xref{Renamed Commands}, for details on what commands were renamed.
+
+@item Ports
+_GDBN__ has been ported to the following new architectures: AT&T 3b1,
+Acorn RISC machine, HP300 running HPUX, big- and little-endian MIPS
+machines, Motorola 88k, Sun 386i, and Sun 3 running SunOS 4. In
+addition, the following are supported as targets only: AMD 29k, Intel
+960, and Wind River's VxWorks.
+
+@item Shared Libraries
+_GDBN__ 4.0 supports SunOS shared libraries.
+
+@item Work in Progress
+Kernel debugging for BSD and Mach systems; Tahoe and HPPA architecture
+support.
+
+@end table
+
+@node Sample Session, Invocation, New Features, Top
+@chapter A Sample _GDBN__ Session
+
+You can use this manual at your leisure to read all about _GDBN__.
+However, a handful of commands are enough to get started using the
+debugger. This chapter illustrates these commands.
+
+@iftex
+In this sample session, we emphasize user input like this: @i{input},
+to make it easier to pick out from the surrounding output.
+@end iftex
+
+@c FIXME: this example may not be appropriate for some configs, where
+@c FIXME...primary interest is in remote use.
+_0__
+One of the preliminary versions of GNU @code{m4} (a generic macro
+processor) exhibits the following bug: sometimes, when we change its
+quote strings from the default, the commands used to capture one macro's
+definition in another stop working. In the following short @code{m4}
+session, we define a macro @code{foo} which expands to @code{0000}; we
+then use the @code{m4} builtin @code{defn} to define @code{bar} as the
+same thing. However, when we change the open quote string to
+@code{<QUOTE>} and the close quote string to @code{<UNQUOTE>}, the same
+procedure fails to define a new synonym @code{baz}:
+
+@smallexample
+$ @i{cd gnu/m4}
+$ @i{./m4}
+@i{define(foo,0000)}
+
+@i{foo}
+0000
+@i{define(bar,defn(`foo'))}
+
+@i{bar}
+0000
+@i{changequote(<QUOTE>,<UNQUOTE>)}
+
+@i{define(baz,defn(<QUOTE>foo<UNQUOTE>))}
+@i{baz}
+@i{C-d}
+m4: End of input: 0: fatal error: EOF in string
+@end smallexample
+
+@noindent
+Let's use _GDBN__ to try to see what's going on.
+
+@smallexample
+$ @i{_GDBP__ m4}
+Reading symbol data from m4...done.
+(_GDBP__)
+@end smallexample
+
+@noindent
+_GDBN__ 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
+
+@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, i960-Nindy Remote, 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 (@pxref{Help}).
+
+@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.
+
+@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
+@item show version
+Show what version of _GDBN__ is running. You should include this
+information in _GDBN__ bug-reports. If multiple versions of _GDBN__ are
+in use at your site, you may occasionally want to make sure what version
+of _GDBN__ you're running; as _GDBN__ evolves, new commands are
+introduced, and old ones may wither away. The version number is also
+announced when you start _GDBN__ with no arguments.
+
+@kindex show copying
+@item show copying
+Display information about permission for copying _GDBN__.
+
+@kindex show warranty
+@item show warranty
+Display the GNU ``NO WARRANTY'' statement.
+@end table
+
+@node Running, Stopping, Commands, Top
+@chapter Running Programs Under _GDBN__
+
+@menu
+* Compilation:: Compiling for Debugging
+* Starting:: Starting your Program
+* Arguments:: Your Program's Arguments
+* Environment:: Your Program's Environment
+* Working Directory:: Your Program's Working Directory
+* Input/Output:: Your Program's Input and Output
+* Attach:: Debugging an Already-Running Process
+* Kill Process:: Killing the Child Process
+@end menu
+
+@node Compilation, Starting, Running, Running
+@section Compiling for Debugging
+
+In order to debug a program effectively, you need to generate
+debugging information when you compile it. This debugging information
+is stored in the object file; it describes the data type of each
+variable or function and the correspondence between source line numbers
+and addresses in the executable code.
+
+To request debugging information, specify the @samp{-g} option when you run
+the compiler.
+
+Many C compilers are unable to handle the @samp{-g} and @samp{-O}
+options together. Using those compilers, you cannot generate optimized
+executables containing debugging information.
+
+The GNU C compiler supports @samp{-g} with or without @samp{-O}, making it
+possible to debug optimized code. We recommend that you @emph{always} use
+@samp{-g} whenever you compile a program. You may think the program is
+correct, but there's no sense in pushing your luck.
+
+Some things do not work as well with @samp{-g -O} as with just
+@samp{-g}, particularly on machines with instruction scheduling. If in
+doubt, recompile with @samp{-g} alone, and if this fixes the problem,
+please report it as a bug (including a test case!).
+
+Older versions of the GNU C compiler permitted a variant option
+@samp{-gg} for debugging information. _GDBN__ no longer supports this
+format; if your GNU C compiler has this option, do not use it.
+
+@ignore
+@comment As far as I know, there are no cases in which _GDBN__ will
+@comment produce strange output in this case. (but no promises).
+If your program includes archives made with the @code{ar} program, and
+if the object files used as input to @code{ar} were compiled without the
+@samp{-g} option and have names longer than 15 characters, _GDBN__ will get
+confused reading the program's symbol table. No error message will be
+given, but _GDBN__ may behave strangely. The reason for this problem is a
+deficiency in the Unix archive file format, which cannot represent file
+names longer than 15 characters.
+
+To avoid this problem, compile the archive members with the @samp{-g}
+option or use shorter file names. Alternatively, use a version of GNU
+@code{ar} dated more recently than August 1989.
+@end ignore
+
+
+@node Starting, Arguments, Compilation, Running
+@section Starting your Program
+@cindex starting
+@cindex running
+@table @code
+@item run
+@itemx r
+@kindex run
+Use the @code{run} command to start your program under _GDBN__.
+_if__(_VXWORKS__)
+Except on VxWorks, you
+_fi__(_VXWORKS__)
+_if__(!_VXWORKS__)
+You
+_fi__(!_VXWORKS__)
+must first specify the program name with an argument to _GDBN__
+(@pxref{Invocation}), or using the @code{file} or @code{exec-file}
+command (@pxref{Files}).@refill
+@end table
+
+On targets that support processes, @code{run} creates an inferior
+process and makes that process run your program. On other targets,
+@code{run} jumps to the start of the program.
+
+The execution of a program is affected by certain information it
+receives from its superior. _GDBN__ provides ways to specify this
+information, which you must do @i{before} starting the program. (You
+can change it after starting the program, but such changes will only affect
+the program the next time you start it.) This information may be
+divided into four categories:
+
+@table @asis
+@item The @i{arguments.}
+You specify the arguments to give your program as the arguments of the
+@code{run} command. If a shell is available on your target, the shell
+is used to pass the arguments, so that you may use normal conventions
+(such as wildcard expansion or variable substitution) in
+describing the arguments. In Unix systems, you can control which shell
+is used with the @code{SHELL} environment variable. @xref{Arguments}.@refill
+
+@item The @i{environment.}
+Your program normally inherits its environment from _GDBN__, but you can
+use the _GDBN__ commands @code{set environment} and @code{unset
+environment} to change parts of the environment that will be given to
+the program. @xref{Environment}.@refill
+
+@item The @i{working directory.}
+Your program inherits its working directory from _GDBN__. You can set
+_GDBN__'s working directory with the @code{cd} command in _GDBN__.
+@xref{Working Directory}.
+
+@item The @i{standard input and output.}
+Your program normally uses the same device for standard input and
+standard output as _GDBN__ is using. You can redirect input and output
+in the @code{run} command line, or you can use the @code{tty} command to
+set a different device for your program.
+@xref{Input/Output}.
+@end table
+
+When you issue the @code{run} command, your program begins to execute
+immediately. @xref{Stopping}, for discussion of how to arrange for your
+program to stop. Once your program has been started by the @code{run}
+command (and then stopped), you may evaluate expressions that involve
+calls to functions in the inferior, using the @code{print} or
+@code{call} commands. @xref{Data}.
+
+If the modification time of your symbol file has changed since the last
+time _GDBN__ read its symbols, _GDBN__ will discard its symbol table and re-read
+it. In this process, it tries to retain your current breakpoints.
+
+@node Arguments, Environment, Starting, Running
+@section Your Program's Arguments
+
+@cindex arguments (to your program)
+The arguments to your program can be specified by the arguments of the
+@code{run} command. They are passed to a shell, which expands wildcard
+characters and performs redirection of I/O, and thence to the program.
+_GDBN__ uses the shell indicated by your environment variable
+@code{SHELL} if it exists; otherwise, _GDBN__ uses @code{/bin/sh}.
+
+@code{run} with no arguments uses the same arguments used by the previous
+@code{run}, or those set by the @code{set args} command.
+
+@kindex set args
+@table @code
+@item set args
+Specify the arguments to be used the next time your program is run. If
+@code{set args} has no arguments, @code{run} will execute your program
+with no arguments. Once you have run your program with arguments,
+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. @footnote{If you use @samp{.} instead,
+it refers to the directory where you executed the @code{path} command.
+_GDBN__ fills in the current path where needed in the @var{directory}
+argument, before adding it to the search path.}
+@c 'path' is explicitly nonrepeatable, but RMS points out it's silly to
+@c document that, since repeating it would be a no-op.
+
+@item show paths
+@kindex show paths
+Display the list of search paths for executables (the @code{PATH}
+environment variable).
+
+@item show environment @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} @var{value}
+@itemx set environment @var{varname} = @var{value}
+@kindex set environment
+Sets environment variable @var{varname} to @var{value}. The value
+changes for your program only, not for _GDBN__ itself. @var{value} may
+be any string; the values of environment variables are just strings, and
+any interpretation is supplied by your program itself. The @var{value}
+parameter is optional; if it is eliminated, the variable is set to a
+null value.
+@c "any string" here doesn't include leading, trailing
+@c blanks. Gnu asks: does anyone care?
+
+For example, this command:
+
+@example
+set env USER = foo
+@end example
+
+@noindent
+tells a Unix program, when subsequently run, that its user is named
+@samp{foo}. (The spaces around @samp{=} are used for clarity here; they
+are not actually required.)
+
+@item unset environment @var{varname}
+@kindex unset environment
+Remove variable @var{varname} from the environment to be passed to your
+program. This is different from @samp{set env @var{varname} =};
+@code{unset environment} removes the variable from the environment,
+rather than assigning it an empty value.
+@end table
+
+@node Working Directory, Input/Output, Environment, Running
+@section Your Program's Working Directory
+
+@cindex working directory (of your program)
+Each time you start your program with @code{run}, it inherits its
+working directory from the current working directory of _GDBN__. _GDBN__'s
+working directory is initially whatever it inherited from its parent
+process (typically the shell), but you can specify a new working
+directory in _GDBN__ with the @code{cd} command.
+
+The _GDBN__ working directory also serves as a default for the commands
+that specify files for _GDBN__ to operate on. @xref{Files}.
+
+@table @code
+@item cd @var{directory}
+@kindex cd
+Set _GDBN__'s working directory to @var{directory}.
+
+@item pwd
+@kindex pwd
+Print _GDBN__'s working directory.
+@end table
+
+@node Input/Output, Attach, Working Directory, Running
+@section Your Program's Input and Output
+
+@cindex redirection
+@cindex i/o
+@cindex terminal
+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
+* Stepping:: Stepping
+* Continuing:: Continuing
+* Signals:: Signals
+@end menu
+
+@node Breakpoints, Stepping, Stopping, Stopping
+@section Breakpoints, Watchpoints, and Exceptions
+
+@cindex breakpoints
+A @dfn{breakpoint} makes your program stop whenever a certain point in
+the program is reached. For each breakpoint, you can add various
+conditions to control in finer detail whether the program will stop.
+You can set breakpoints with the @code{break} command and its variants
+(@pxref{Set Breaks}), to specify the place where the program should stop
+by line number, function name or exact address in the program. In
+languages with exception handling (such as GNU C++), you can also set
+breakpoints where an 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. @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
+@c FIXME: 2nd sentence below C++ only?
+Set breakpoints on all functions matching the regular expression
+@var{regex}. This is useful for setting breakpoints on overloaded
+functions that are not members of any special classes. This command
+sets an unconditional breakpoint on all matches, printing a list of all
+breakpoints it set. Once these breakpoints are set, they are treated
+just like the breakpoints set with the @code{break} command. They can
+be deleted, disabled, made conditional, etc., in the standard ways.
+
+@kindex info breakpoints
+@kindex $_
+@item info breakpoints @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. _GDBN__
+can be used to examine what caused the program to raise an exception
+and to list the exceptions the program is prepared to handle at a
+given point in time.
+
+@table @code
+@item catch @var{exceptions}
+@kindex catch
+You can set breakpoints at active exception handlers by using the
+@code{catch} command. @var{exceptions} is a list of names of exceptions
+to catch.
+@end table
+
+You can use @code{info catch} to list active exception handlers;
+@pxref{Frame Info}.
+
+There are currently some limitations to exception handling in _GDBN__.
+These will be corrected in a future release.
+
+@itemize @bullet
+@item
+If you call a function interactively, _GDBN__ normally returns
+control to you when the function has finished executing. If the call
+raises an exception, however, the call may bypass the mechanism that
+returns control to the user and cause the program to simply continue
+running until it hits a breakpoint, catches a signal that _GDBN__ is
+listening for, or exits.
+@item
+You cannot raise an exception interactively.
+@item
+You cannot interactively install an exception handler.
+@end itemize
+
+@cindex raise exceptions
+Sometimes @code{catch} is not the best way to debug exception handling:
+if you need to know exactly where an exception is raised, it's better to
+stop @emph{before} the exception handler is called, since that way you
+can see the stack before any unwinding takes place. If you set a
+breakpoint in an exception handler instead, it may not be easy to find
+out where the exception was raised.
+
+To stop just before an exception handler is called, you need some
+knowledge of the implementation. In the case of GNU C++ exceptions are
+raised by calling a library function named @code{__raise_exception}
+which has the following ANSI C interface:
+
+@example
+ /* ADDR is where the exception identifier is stored.
+ ID is the exception identifier. */
+ void __raise_exception (void **@var{addr}, void *@var{id});
+@end example
+
+@noindent
+To make the debugger catch all exceptions before any stack
+unwinding takes place, set a breakpoint on @code{__raise_exception}
+(@pxref{Breakpoints}).
+
+With a conditional breakpoint (@xref{Conditions}) that depends on the
+value of @var{id}, you can stop your program when a specific exception
+is raised. You can use multiple conditional breakpoints to stop the
+program when any of a number of exceptions are raised.
+
+@node Delete Breaks, Disabling, Exception Handling, Breakpoints
+@subsection Deleting Breakpoints
+
+@cindex clearing breakpoints, watchpoints
+@cindex deleting breakpoints, watchpoints
+It is often necessary to eliminate a breakpoint or watchpoint once it
+has done its job and you no longer want the program to stop there. This
+is called @dfn{deleting} the breakpoint. A breakpoint that has been
+deleted no longer exists; 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{Stepping}.)
+
+@node Conditions, Break Commands, Disabling, Breakpoints
+@subsection Break Conditions
+@cindex conditional breakpoints
+@cindex breakpoint conditions
+
+The simplest sort of breakpoint breaks every time the program reaches a
+specified place. You can also specify a @dfn{condition} for a
+breakpoint. A condition is just a Boolean expression in your
+programming language. (@xref{Expressions}). A breakpoint with a
+condition evaluates the expression each time the program reaches it, and
+the program stops only if the condition is true.
+
+Conditions are also accepted for watchpoints; you may not need them,
+since a watchpoint is inspecting the value of an expression anyhow---but
+it might be simpler, say, to just set a watchpoint on a variable name,
+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 C++ overloading
+@cindex symbol overloading
+
+Some programming languages (notably C++) permit a single function name
+to be defined several times, for application in different contexts.
+This is called @dfn{overloading}. When a function name is overloaded,
+@samp{break @var{function}} is not enough to tell _GDBN__ where you
+want a breakpoint. _GDBN__ 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 Stepping, Continuing, Breakpoints, Stopping
+@section Stepping
+
+@cindex stepping
+@dfn{Stepping} means setting your program in motion for a limited time,
+so that control will return automatically to _GDBN__ after one line of
+code or one machine instruction. @footnote{Your program might stop even
+sooner, during stepping, since a signal may arrive before your program
+reaches the next source line. Also, since breakpoints are active during
+stepping, your program will stop for them even if it has not gone as far
+as the stepping command specifies.}
+
+A typical technique for using stepping is to put a breakpoint
+(@pxref{Breakpoints}) at the beginning of the function or the section of
+the program in which a problem is believed to lie, run the program until
+it stops at that breakpoint, and then step through the suspect area,
+examining the variables that are interesting, until you see the problem
+happen.
+
+@table @code
+@item step
+@kindex step
+@kindex s
+Continue running the program until control reaches a different source
+line, then stop it and return control to the debugger. This command is
+abbreviated @code{s}.
+
+You may use the @code{step} command when control is within a function
+for which there is no debugging information. In that case, execution
+will proceed until control reaches a different function, or is about to
+return from this function.
+
+@item step @var{count}
+Continue running as in @code{step}, but do so @var{count} times. If a
+breakpoint is reached or a signal not related to stepping occurs before
+@var{count} steps, stepping stops right away.
+
+@item next
+@kindex next
+@kindex n
+Continue to the next source line in the current stack frame. Similar to
+@code{step}, but any function calls appearing within the line of code
+are executed without stopping. Execution stops when control reaches a
+different line of code at the stack level which was executing when the
+@code{next} command was given. This command is abbreviated @code{n}.
+
+An argument is a repeat count, as in @code{step}.
+
+@code{next} within a function that lacks debugging information acts like
+@code{step}, but any function calls appearing within the code of the
+function are executed without stopping.
+
+@item finish
+@kindex finish
+Continue running until just after the selected stack frame returns (or
+until there is some other reason to stop, such as a fatal signal or a
+breakpoint). Print the value returned by the selected stack frame (if
+any).
+
+Contrast this with the @code{return} command (@pxref{Returning}).
+
+@item until
+@kindex until
+@item u
+@kindex u
+Continue running until a source line past the current line, in the
+current stack frame, is reached. This command is used to avoid single
+stepping through a loop more than once. It is like the @code{next}
+command, except that when @code{until} encounters a jump, it
+automatically continues execution until the program counter is greater
+than the address of the jump.
+
+This means that when you reach the end of a loop after single stepping
+though it, @code{until} will cause the program to continue execution
+until the loop is exited. In contrast, a @code{next} command at the end
+of a loop will simply step back to the beginning of the loop, which
+would force you to step through the next iteration.
+
+@code{until} always stops the program if it attempts to exit the current
+stack frame.
+
+@code{until} may produce somewhat counterintuitive results if the order
+of the source lines does not match the actual order of execution. For
+example, in the following excerpt from a debugging session, the @code{f}
+(@code{frame}) command shows that execution is stopped at line
+@code{206}; yet when we use @code{until}, we get to line @code{195}:
+
+@example
+(_GDBP__) f
+#0 main (argc=4, argv=0xf7fffae8) at m4.c:206
+206 expand_input();
+(_GDBP__) until
+195 for ( ; argc > 0; NEXTARG) @{
+@end example
+
+In this case, (as for any C @code{for}-loop), the loop-step expression
+(here, @samp{argc > 0}) is executed @emph{after} the statements in the
+body of the loop, but is written before them. Therefore, the
+@code{until} command appeared to step back to the beginning of the loop
+when it advanced to this expression. However, it has not really gone to
+an earlier statement---not in terms of the actual machine code.
+
+@code{until} with no argument works by means of single
+instruction stepping, and hence is slower than @code{until} with an
+argument.
+
+@item until @var{location}
+@item u @var{location}
+Continue running the program until either the specified location is
+reached, or the current (innermost) stack frame returns. @var{location}
+is any of the forms of argument acceptable to @code{break} (@pxref{Set
+Breaks}). This form of the command uses breakpoints, and hence is
+quicker than @code{until} without an argument.
+
+@item stepi
+@itemx si
+@kindex stepi
+@kindex si
+Execute one machine instruction, then stop and return to the debugger.
+
+It is often useful to do @samp{display/i $pc} when stepping by machine
+instructions. This will cause the next instruction to be executed to
+be displayed automatically at each stop. @xref{Auto Display}.
+
+An argument is a repeat count, as in @code{step}.
+
+@item nexti
+@itemx ni
+@kindex nexti
+@kindex ni
+Execute one machine instruction, but if it is a function call,
+proceed until the function returns.
+
+An argument is a repeat count, as in @code{next}.
+@end table
+
+The @code{continue} command can be used after stepping to resume execution
+until the next breakpoint or signal.
+
+@node Continuing, Signals, Stepping, Stopping
+@section Continuing
+
+After your program stops, most likely you will want it to run some more if
+the bug you are looking for has not happened yet.
+
+@table @code
+@item continue
+@kindex continue
+Continue running the program at the place where it stopped.
+@end table
+
+If the program stopped at a breakpoint, the place to continue running
+is the address of the breakpoint. You might expect that continuing would
+just stop at the same breakpoint immediately. In fact, @code{continue}
+takes special care to prevent that from happening. You do not need
+to disable the breakpoint to proceed through it after stopping there.
+You can, however, specify an ignore-count for the breakpoint that the
+program stopped at, by means of an argument to the @code{continue} command.
+@xref{Conditions}.
+
+If the program stopped because of a signal other than @code{SIGINT} or
+@code{SIGTRAP}, continuing will cause the program to see that signal.
+You may not want this to happen. For example, if the program stopped
+due to some sort of memory reference error, you might store correct
+values into the erroneous variables and continue, hoping to see more
+execution; but the program would probably terminate immediately as
+a result of the fatal signal once it sees the signal. To prevent this,
+you can continue with @samp{signal 0}. @xref{Signaling}. You can
+also act in advance to control what signals your program will see, using
+the @code{handle} command (@pxref{Signals}).
+
+@node Signals, , Continuing, Stopping
+@section Signals
+@cindex signals
+
+A signal is an asynchronous event that can happen in a program. The
+operating system defines the possible kinds of signals, and gives each
+kind a name and a number. For example, in Unix @code{SIGINT} is the
+signal a program gets when you type an interrupt (often @kbd{C-c});
+@code{SIGSEGV} is the signal a program gets from referencing a place in
+memory far away from all the areas in use; @code{SIGALRM} occurs when
+the alarm clock timer goes off (which happens only if the program has
+requested an alarm).
+
+@cindex fatal signals
+Some signals, including @code{SIGALRM}, are a normal part of the
+functioning of the program. Others, such as @code{SIGSEGV}, indicate
+errors; these signals are @dfn{fatal} (kill the program immediately) if the
+program has not specified in advance some other way to handle the signal.
+@code{SIGINT} does not indicate an error in the program, but it is normally
+fatal so it can carry out the purpose of the interrupt: to kill the program.
+
+_GDBN__ has the ability to detect any occurrence of a signal in the program
+running under _GDBN__'s control. You can tell _GDBN__ in advance what to do for
+each kind of signal.
+
+@cindex handling signals
+Normally, _GDBN__ is set up to ignore non-erroneous signals like @code{SIGALRM}
+(so as not to interfere with their role in the functioning of the program)
+but to stop the program immediately whenever an error signal happens.
+You can change these settings with the @code{handle} command.
+
+@table @code
+@item info signals
+@kindex info signals
+Print a table of all the kinds of signals and how _GDBN__ has been told to
+handle each one. You can use this to see the signal numbers of all
+the defined types of signals.
+
+@item handle @var{signal} @var{keywords}@dots{}
+@kindex handle
+Change the way _GDBN__ handles signal @var{signal}. @var{signal} can be the
+number of a signal or its name (with or without the @samp{SIG} at the
+beginning). The @var{keywords} say what change to make.
+@end table
+
+@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. @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 address of the frame's arguments, the program counter saved in it
+(the address of execution in the caller frame), and which registers
+were saved in the frame. The verbose description is useful when
+something has gone wrong that has made the stack format fail to fit
+the usual conventions.
+
+@item info frame @var{addr}
+@itemx info f @var{addr}
+Print a verbose description of the frame at address @var{addr},
+without selecting that frame. The selected frame remains unchanged by
+this command.
+
+@item info args
+@kindex info args
+Print the arguments of the selected frame, each on a separate line.
+
+@item info locals
+@kindex info locals
+Print the local variables of the selected frame, each on a separate
+line. These are all variables declared static or automatic within all
+program blocks that execution in this frame is currently inside of.
+
+@item info catch
+@kindex info catch
+@cindex catch exceptions
+@cindex exception handlers
+Print a list of all the exception handlers that are active in the
+current stack frame at the current point of execution. To see other
+exception handlers, visit the associated frame (using the @code{up},
+@code{down}, or @code{frame} commands); then type @code{info catch}.
+@xref{Exception Handling}.
+@end table
+
+@node Source, Data, Stack, Top
+@chapter Examining Source Files
+
+_GDBN__ can print parts of your program's source, since the debugging
+information recorded in your program tells _GDBN__ what source files
+were used to built it. When your program stops, _GDBN__ spontaneously
+prints the line where it stopped. Likewise, when you select a stack
+frame (@pxref{Selection}), _GDBN__ prints the line where execution in
+that frame has stopped. You can print other portions of source files by
+explicit command.
+
+If you use _GDBN__ through its GNU Emacs interface, you may prefer to
+use Emacs facilities to view source; @pxref{Emacs}.
+
+@menu
+* List:: Printing Source Lines
+* Search:: Searching Source Files
+* Source Path:: Specifying Source Directories
+* Machine Code:: Source and Machine Code
+@end menu
+
+@node List, Search, Source, Source
+@section Printing Source Lines
+
+@kindex list
+@kindex l
+To print lines from a source file, use the @code{list} command
+(abbreviated @code{l}). There are several ways to specify what part
+of the file you want to print.
+
+Here are the forms of the @code{list} command most commonly used:
+
+@table @code
+@item list @var{linenum}
+Print ten lines centered around line number @var{linenum} in the
+current source file.
+
+@item list @var{function}
+Print ten lines centered around the beginning of function
+@var{function}.
+
+@item list
+Print ten more lines. If the last lines printed were printed with a
+@code{list} command, this prints ten lines following the last lines
+printed; however, if the last line printed was a solitary line printed
+as part of displaying a stack frame (@pxref{Stack}), this prints ten
+lines centered around that line.
+
+@item list -
+Print ten lines just before the lines last printed.
+@end table
+
+Repeating a @code{list} command with @key{RET} discards the argument,
+so it is equivalent to typing just @code{list}. This is more useful
+than listing the same lines again. An exception is made for an
+argument of @samp{-}; that argument is preserved in repetition so that
+each repetition moves up in the source file.
+
+@cindex linespec
+In general, the @code{list} command expects you to supply zero, one or two
+@dfn{linespecs}. Linespecs specify source lines; there are several ways
+of writing them but the effect is always to specify some source line.
+Here is a complete description of the possible arguments for @code{list}:
+
+@table @code
+@item list @var{linespec}
+Print ten lines centered around the line specified by @var{linespec}.
+
+@item list @var{first},@var{last}
+Print lines from @var{first} to @var{last}. Both arguments are
+linespecs.
+
+@item list ,@var{last}
+Print ten lines ending with @var{last}.
+
+@item list @var{first},
+Print ten lines starting with @var{first}.
+
+@item list +
+Print ten lines just after the lines last printed.
+
+@item list -
+Print ten lines just before the lines last printed.
+
+@item list
+As described in the preceding table.
+@end table
+
+Here are the ways of specifying a single source line---all the
+kinds of linespec.
+
+@table @code
+@item @var{number}
+Specifies line @var{number} of the current source file.
+When a @code{list} command has two linespecs, this refers to
+the same source file as the first linespec.
+
+@item +@var{offset}
+Specifies the line @var{offset} lines after the last line printed.
+When used as the second linespec in a @code{list} command that has
+two, this specifies the line @var{offset} lines down from the
+first linespec.
+
+@item -@var{offset}
+Specifies the line @var{offset} lines before the last line printed.
+
+@item @var{filename}:@var{number}
+Specifies line @var{number} in the source file @var{filename}.
+
+@item @var{function}
+@c FIXME: "of the open-brace" is C-centric. When we add other langs...
+Specifies the line of the open-brace that begins the body of the
+function @var{function}.
+
+@item @var{filename}:@var{function}
+Specifies the line of the open-brace that begins the body of the
+function @var{function} in the file @var{filename}. You only need the
+file name with a function name to avoid ambiguity when there are
+identically named functions in different source files.
+
+@item *@var{address}
+Specifies the line containing the program address @var{address}.
+@var{address} may be any expression.
+@end table
+
+@node Search, Source Path, List, Source
+@section Searching Source Files
+@cindex searching
+@kindex reverse-search
+
+There are two commands for searching through the current source file for a
+regular expression.
+
+@table @code
+@item forward-search @var{regexp}
+@itemx search @var{regexp}
+@kindex search
+@kindex forward-search
+The command @samp{forward-search @var{regexp}} checks each line, starting
+with the one following the last line listed, for a match for @var{regexp}.
+It lists the line that is found. You can abbreviate the command name
+as @code{fo}. The synonym @samp{search @var{regexp}} is also supported.
+
+@item reverse-search @var{regexp}
+The command @samp{reverse-search @var{regexp}} checks each line, starting
+with the one before the last line listed and going backward, for a match
+for @var{regexp}. It lists the line that is found. You can abbreviate
+this command as @code{rev}.
+@end table
+
+@node Source Path, Machine Code, Search, Source
+@section Specifying Source Directories
+
+@cindex source path
+@cindex directories for source files
+Executable programs sometimes do not record the directories of the source
+files from which they were compiled, just the names. Even when they do,
+the directories could be moved between the compilation and your debugging
+session. _GDBN__ has a list of directories to search for source files;
+this is called the @dfn{source path}. Each time _GDBN__ wants a source file,
+it tries all the directories in the list, in the order they are present
+in the list, until it finds a file with the desired name. Note that
+the executable search path is @emph{not} used for this purpose. Neither is
+the current working directory, unless it happens to be in the source
+path.
+
+If _GDBN__ can't find a source file in the source path, and the object
+program records a directory, _GDBN__ tries that directory too. If the
+source path is empty, and there is no record of the compilation
+directory, _GDBN__ will, as a last resort, look in the current
+directory.
+
+Whenever you reset or rearrange the source path, _GDBN__ will clear out
+any information it has cached about where source files are found, where
+each line is in the file, etc.
+
+@kindex directory
+When you start _GDBN__, its source path is empty.
+To add other directories, use the @code{directory} command.
+
+@table @code
+@item directory @var{dirname} @dots{}
+Add directory @var{dirname} to the front of the source path. Several
+directory names may be given to this command, separated by @samp{:} or
+whitespace. You may specify a directory that is already in the source
+path; this moves it forward, so it will be searched sooner. You can use
+the string @samp{$cdir} to refer to the compilation directory (if one is
+recorded), and @samp{$cwd} to refer to the current working directory.
+@footnote{@samp{$cwd} is not the same as @samp{.}---the former tracks
+the current working directory as it changes during your _GDBN__ session,
+while the latter is immediately expanded to the current directory at the
+time you add an entry to the source path.}
+
+@item directory
+Reset the source path to empty again. This requires confirmation.
+
+@c RET-repeat for @code{directory} is explicitly disabled, but since
+@c repeating it would be a no-op we don't say that. (thanks to RMS)
+
+@item show directories
+@kindex show directories
+Print the source path: show which directories it contains.
+@end table
+
+If your source path is cluttered with directories that are no longer of
+interest, _GDBN__ may sometimes cause confusion by finding the wrong
+versions of source. You can correct the situation as follows:
+
+@enumerate
+@item
+Use @code{directory} with no argument to reset the source path to empty.
+
+@item
+Use @code{directory} with suitable arguments to reinstall the
+directories you want in the source path. You can add all the
+directories in one command.
+@end enumerate
+
+@node Machine Code, , Source Path, Source
+@section Source and Machine Code
+You can use the command @code{info line} to map source lines to program
+addresses (and viceversa), and the command @code{disassemble} to display
+a range of addresses as machine instructions.
+
+@table @code
+@item info line @var{linespec}
+@kindex info line
+Print the starting and ending addresses of the compiled code for
+source line @var{linespec}. You can specify source lines in any of the
+ways understood by the @code{list} command (@pxref{List}).
+@end table
+
+For example, we can use @code{info line} to inquire on where the object
+code for the first line of function @code{m4_changequote} lies:
+@smallexample
+(_GDBP__) info line m4_changecom
+Line 895 of "builtin.c" starts at pc 0x634c and ends at 0x6350.
+@end smallexample
+
+@noindent
+We can also inquire (using @code{*@var{addr}} as the form for
+@var{linespec}) what source line covers a particular address:
+@smallexample
+(_GDBP__) info line *0x63ff
+Line 926 of "builtin.c" starts at pc 0x63e4 and ends at 0x6404.
+@end smallexample
+
+@kindex $_
+After @code{info line}, the default address for the @code{x}
+command is changed to the starting address of the line, so that
+@samp{x/i} is sufficient to begin examining the machine code
+(@pxref{Memory}). Also, this address is saved as the value of the
+convenience variable @code{$_} (@pxref{Convenience Vars}).
+
+@table @code
+@kindex disassemble
+@item disassemble
+This specialized command is provided to dump a range of memory as
+machine instructions. The default memory range is the function
+surrounding the program counter of the selected frame. A single
+argument to this command is a program counter value; the function
+surrounding this value will be dumped. Two arguments (separated by one
+or more spaces) specify a range of addresses (first inclusive, second
+exclusive) to be dumped.
+@end table
+
+We can use @code{disassemble} to inspect the object code
+range shown in the last @code{info line} example:
+
+@smallexample
+(_GDBP__) disas 0x63e4 0x6404
+Dump of assembler code from 0x63e4 to 0x6404:
+0x63e4 <builtin_init+5340>: ble 0x63f8 <builtin_init+5360>
+0x63e8 <builtin_init+5344>: sethi %hi(0x4c00), %o0
+0x63ec <builtin_init+5348>: ld [%i1+4], %o0
+0x63f0 <builtin_init+5352>: b 0x63fc <builtin_init+5364>
+0x63f4 <builtin_init+5356>: ld [%o0+4], %o0
+0x63f8 <builtin_init+5360>: or %o0, 0x1a4, %o0
+0x63fc <builtin_init+5364>: call 0x9288 <path_search>
+0x6400 <builtin_init+5368>: nop
+End of assembler dump.
+(_GDBP__)
+
+@end smallexample
+
+@node Data, Symbols, Source, Top
+@chapter Examining Data
+
+@cindex printing data
+@cindex examining data
+@kindex print
+@kindex inspect
+@c "inspect" isn't quite a synonym if you're using Epoch, which we don't
+@c document because it's nonstandard... Under Epoch it displays in a
+@c different window or something like that.
+The usual way to examine data in your program is with the @code{print}
+command (abbreviated @code{p}), or its synonym @code{inspect}. It
+evaluates and prints the value of any valid expression of the language
+the program is written in (for now, C or C++). You type
+
+@example
+print @var{exp}
+@end example
+
+@noindent
+where @var{exp} is any valid expression (in the source language), and
+the value of @var{exp} is printed in a format appropriate to its data
+type.
+
+A more low-level way of examining data is with the @code{x} command.
+It examines data in memory at a specified address and prints it in a
+specified format. @xref{Memory}.
+
+@menu
+* Expressions:: Expressions
+* Variables:: Program Variables
+* Arrays:: Artificial Arrays
+* Output formats:: Output formats
+* Memory:: Examining Memory
+* Auto Display:: Automatic Display
+* Print Settings:: Print Settings
+* Value History:: Value History
+* Convenience Vars:: Convenience Variables
+* Registers:: Registers
+* Floating Point Hardware:: Floating Point Hardware
+@end menu
+
+@node Expressions, Variables, Data, Data
+@section Expressions
+
+@cindex expressions
+@code{print} and many other _GDBN__ commands accept an expression and
+compute its value. Any kind of constant, variable or operator defined
+by the programming language you are using is legal in an expression in
+_GDBN__. This includes conditional expressions, function calls, casts
+and string constants. It unfortunately does not include symbols defined
+by preprocessor @code{#define} commands, or C++ expressions involving
+@samp{::}, the name resolution operator.
+@c FIXME: actually C++ a::b works except in obscure circumstances where it
+@c FIXME...can conflict with GDB's own name scope resolution.
+
+Casts are supported in all languages, not just in C, because it is so
+useful to cast a number into a pointer so as to examine a structure
+at that address in memory.
+
+_GDBN__ supports three kinds of operator in addition to those of programming
+languages:
+
+@table @code
+@item @@
+@samp{@@} is a binary operator for treating parts of memory as arrays.
+@xref{Arrays}, for more information.
+
+@item ::
+@samp{::} allows you to specify a variable in terms of the file or
+function where it is defined. @xref{Variables}.
+
+@item @{@var{type}@} @var{addr}
+Refers to an object of type @var{type} stored at address @var{addr} in
+memory. @var{addr} may be any expression whose value is an integer or
+pointer (but parentheses are required around binary operators, just as in
+a cast). This construct is allowed regardless of what kind of data is
+normally supposed to reside at @var{addr}.@refill
+@end table
+
+@node Variables, Arrays, Expressions, Data
+@section Program Variables
+
+The most common kind of expression to use is the name of a variable
+in your program.
+
+Variables in expressions are understood in the selected stack frame
+(@pxref{Selection}); they must either be global (or static) or be visible
+according to the scope rules of the programming language from the point of
+execution in that frame. This means that in the function
+
+@example
+foo (a)
+ int a;
+@{
+ bar (a);
+ @{
+ int b = test ();
+ bar (b);
+ @}
+@}
+@end example
+
+@noindent
+the variable @code{a} is usable whenever the program is executing
+within the function @code{foo}, but the variable @code{b} is visible
+only while the program is executing inside the block in which @code{b}
+is declared.
+
+@cindex variable name conflict
+There is an exception: you can refer to a variable or function whose
+scope is a single source file even if the current execution point is not
+in this file. But it is possible to have more than one such variable or
+function with the same name (in different source files). If that happens,
+referring to that name has unpredictable effects. If you wish, you can
+specify a variable in a particular file, using the colon-colon notation:
+
+@cindex colon-colon
+@kindex ::
+@example
+@var{file}::@var{variable}
+@end example
+
+@noindent
+Here @var{file} is the name of the source file whose variable you want.
+
+@cindex C++ name resolution
+This use of @samp{::} is very rarely in conflict with the very similar
+use of the same notation in C++. _GDBN__ also supports use of the C++
+name resolution operator in _GDBN__ expressions.
+
+@node Arrays, Output formats, Variables, Data
+@section Artificial Arrays
+
+@cindex artificial array
+@kindex @@
+It is often useful to print out several successive objects of the
+same type in memory; a section of an array, or an array of
+dynamically determined size for which only a pointer exists in the
+program.
+
+This can be done by constructing an @dfn{artificial array} with the
+binary operator @samp{@@}. The left operand of @samp{@@} should be
+the first element of the desired array, as an individual object.
+The right operand should be the desired length of the array. The result is
+an array value whose elements are all of the type of the left argument.
+The first element is actually the left argument; the second element
+comes from bytes of memory immediately following those that hold the
+first element, and so on. Here is an example. If a program says
+
+@example
+int *array = (int *) malloc (len * sizeof (int));
+@end example
+
+@noindent
+you can print the contents of @code{array} with
+
+@example
+p *array@@len
+@end example
+
+The left operand of @samp{@@} must reside in memory. Array values made
+with @samp{@@} in this way behave just like other arrays in terms of
+subscripting, and are coerced to pointers when used in expressions.
+Artificial arrays most often appear in expressions via the value history
+(@pxref{Value History}), after printing one out.)
+
+@node Output formats, Memory, Arrays, Data
+@section Output formats
+
+@cindex formatted output
+@cindex output formats
+By default, _GDBN__ prints a value according to its data type. Sometimes
+this is not what you want. For example, you might want to print a number
+in hex, or a pointer in decimal. Or you might want to view data in memory
+at a certain address as a character string or as an instruction. To do
+these things, specify an @dfn{output format} when you print a value.
+
+The simplest use of output formats is to say how to print a value
+already computed. This is done by starting the arguments of the
+@code{print} command with a slash and a format letter. The format
+letters supported are:
+
+@table @code
+@item x
+Regard the bits of the value as an integer, and print the integer in
+hexadecimal.
+
+@item d
+Print as integer in signed decimal.
+
+@item u
+Print as integer in unsigned decimal.
+
+@item o
+Print as integer in octal.
+
+@item t
+Print as integer in binary. The letter @samp{t} stands for ``two''.
+
+@item a
+Print as an address, both absolute in hex and as an offset from the
+nearest preceding symbol. This format can be used to discover where (in
+what function) an unknown address is located:
+@example
+(_GDBP__) p/a 0x54320
+_0__$3 = 0x54320 <_initialize_vx+396>_1__
+@end example
+
+
+@item c
+Regard as an integer and print it as a character constant.
+
+@item f
+Regard the bits of the value as a floating point number and print
+using typical floating point syntax.
+@end table
+
+For example, to print the program counter in hex (@pxref{Registers}), type
+
+@example
+p/x $pc
+@end example
+
+@noindent
+Note that no space is required before the slash; this is because command
+names in _GDBN__ cannot contain a slash.
+
+To reprint the last value in the value history with a different format,
+you can use the @code{print} command with just a format and no
+expression. For example, @samp{p/x} reprints the last value in hex.
+
+@node Memory, Auto Display, Output formats, Data
+@section Examining Memory
+
+@cindex examining memory
+@table @code
+@kindex x
+@item x/@var{nfu} @var{expr}
+The command @code{x} (for `examine') can be used to examine memory
+without being constrained by your program's data types. You can specify
+the unit size @var{u} of memory to inspect, and a repeat count @var{n} of how
+many of those units to display. @code{x} understands the formats
+@var{f} used by @code{print}; two additional formats, @samp{s} (string)
+and @samp{i} (machine instruction) can be used without specifying a unit
+size.
+@end table
+
+For example, @samp{x/3uh 0x54320} is a request to display three halfwords
+(@code{h}) of memory, formatted as unsigned decimal integers (@samp{u}),
+starting at address @code{0x54320}. @samp{x/4xw $sp} prints the four
+words (@samp{w}) of memory above the stack pointer (here, @samp{$sp};
+@pxref{Registers}) in hexadecimal (@samp{x}).
+
+Since the letters indicating unit sizes are all distinct from the
+letters specifying output formats, you don't have to remember whether
+unit size or format comes first; either order will work. The output
+specifications @samp{4xw} and @samp{4wx} mean exactly the same thing.
+
+After the format specification, you supply an expression for the address
+where _GDBN__ is to begin reading from memory. The expression need not
+have a pointer value (though it may); it is always interpreted as an
+integer address of a byte of memory. @xref{Expressions} for more
+information on expressions.
+
+These are the memory units @var{u} you can specify with the @code{x}
+command:
+
+@table @code
+@item b
+Examine individual bytes.
+
+@item h
+Examine halfwords (two bytes each).
+
+@item w
+Examine words (four bytes each).
+
+@cindex word
+Many assemblers and cpu designers still use `word' for a 16-bit quantity,
+as a holdover from specific predecessor machines of the 1970's that really
+did use two-byte words. But more generally the term `word' has always
+referred to the size of quantity that a machine normally operates on and
+stores in its registers. This is 32 bits for all the machines that _GDBN__
+runs on.
+
+@item g
+Examine giant words (8 bytes).
+@end table
+
+You can combine these unit specifications with any of the formats
+described for @code{print}. @xref{Output formats}.
+
+@code{x} has two additional output specifications which derive the unit
+size from the data inspected:
+
+@table @code
+@item s
+Print a null-terminated string of characters. Any explicitly specified
+unit size is ignored; instead, the unit is however many bytes it takes
+to reach a null character (including the null character).
+
+@item i
+Print a machine instruction in assembler syntax (or nearly). Any
+specified unit size is ignored; the number of bytes in an instruction
+varies depending on the type of machine, the opcode and the addressing
+modes used. The command @code{disassemble} gives an alternative way of
+inspecting machine instructions. @xref{Machine Code}.
+@end table
+
+If you omit either the format @var{f} or the unit size @var{u}, @code{x}
+will use the same one that was used last. If you don't use any letters
+or digits after the slash, you can omit the slash as well.
+
+You can also omit the address to examine. Then the address used is just
+after the last unit examined. This is why string and instruction
+formats actually compute a unit-size based on the data: so that the next
+string or instruction examined will start in the right place.
+
+When the @code{print} command shows a value that resides in memory,
+@code{print} also sets the default address for the @code{x} command.
+@code{info line} also sets the default for @code{x}, to the address of
+the start of the machine code for the specified line (@pxref{Machine
+Code}), and @code{info breakpoints} sets it to the address of the last
+breakpoint listed (@pxref{Set Breaks}).
+
+When you use @key{RET} to repeat an @code{x} command, the address
+specified previously (if any) is ignored, so that the repeated command
+examines the successive locations in memory rather than the same ones.
+
+You can examine several consecutive units of memory with one command by
+writing a repeat-count after the slash (before the format letters, if
+any). Omitting the repeat count @var{n} displays one unit of the
+appropriate size. The repeat count must be a decimal integer. It has
+the same effect as repeating the @code{x} command @var{n} times except
+that the output may be more compact, with several units per line. For
+example,
+
+@example
+x/10i $pc
+@end example
+
+@noindent
+prints ten instructions starting with the one to be executed next in the
+selected frame. After doing this, you could print a further seven
+instructions with
+
+@example
+x/7
+@end example
+
+@noindent
+---where the format and address are allowed to default.
+
+@kindex $_
+@kindex $__
+The addresses and contents printed by the @code{x} command are not put
+in the value history because there is often too much of them and they
+would get in the way. Instead, _GDBN__ makes these values available for
+subsequent use in expressions as values of the convenience variables
+@code{$_} and @code{$__}. After an @code{x} command, the last address
+examined is available for use in expressions in the convenience variable
+@code{$_}. The contents of that address, as examined, are available in
+the convenience variable @code{$__}.
+
+If the @code{x} command has a repeat count, the address and contents saved
+are from the last memory unit printed; this is not the same as the last
+address printed if several units were printed on the last line of output.
+
+@node Auto Display, Print Settings, Memory, Data
+@section Automatic Display
+@cindex automatic display
+@cindex display of expressions
+
+If you find that you want to print the value of an expression frequently
+(to see how it changes), you might want to add it to the @dfn{automatic
+display list} so that _GDBN__ will print its value each time the program stops.
+Each expression added to the list is given a number to identify it;
+to remove an expression from the list, you specify that number.
+The automatic display looks like this:
+
+@example
+2: foo = 38
+3: bar[5] = (struct hack *) 0x3804
+@end example
+
+@noindent
+showing item numbers, expressions and their current values. As with
+displays you request manually using @code{x} or @code{print}, you can
+specify the output format you prefer; in fact, @code{display} decides
+whether to use @code{print} or @code{x} depending on how elaborate your
+format specification is---it uses @code{x} if you specify a unit size,
+or one of the two formats (@samp{i} and @samp{s}) that are only
+supported by @code{x}; otherwise it uses @code{print}.
+
+@table @code
+@item display @var{exp}
+@kindex display
+Add the expression @var{exp} to the list of expressions to display
+each time the program stops. @xref{Expressions}.
+
+@code{display} will not repeat if you press @key{RET} again after using it.
+
+@item display/@var{fmt} @var{exp}
+For @var{fmt} specifying only a display format and not a size or
+count, add the expression @var{exp} to the auto-display list but
+arranges to display it each time in the specified format @var{fmt}.
+@xref{Output formats}.
+
+@item display/@var{fmt} @var{addr}
+For @var{fmt} @samp{i} or @samp{s}, or including a unit-size or a
+number of units, add the expression @var{addr} as a memory address to
+be examined each time the program stops. Examining means in effect
+doing @samp{x/@var{fmt} @var{addr}}. @xref{Memory}.
+@end table
+
+For example, @samp{display/i $pc} can be helpful, to see the machine
+instruction about to be executed each time execution stops (@samp{$pc}
+is a common name for the program counter; @pxref{Registers}).
+
+@table @code
+@item undisplay @var{dnums}@dots{}
+@itemx delete display @var{dnums}@dots{}
+@kindex delete display
+@kindex undisplay
+Remove item numbers @var{dnums} from the list of expressions to display.
+
+@code{undisplay} will not repeat if you press @key{RET} after using it.
+(Otherwise you would just get the error @samp{No display number @dots{}}.)
+
+@item disable display @var{dnums}@dots{}
+@kindex disable display
+Disable the display of item numbers @var{dnums}. A disabled display
+item is not printed automatically, but is not forgotten. It may be
+enabled again later.
+
+@item enable display @var{dnums}@dots{}
+@kindex enable display
+Enable display of item numbers @var{dnums}. It becomes effective once
+again in auto display of its expression, until you specify otherwise.
+
+@item display
+Display the current values of the expressions on the list, just as is
+done when the program stops.
+
+@item info display
+@kindex info display
+Print the list of expressions previously set up to display
+automatically, each one with its item number, but without showing the
+values. This includes disabled expressions, which are marked as such.
+It also includes expressions which would not be displayed right now
+because they refer to automatic variables not currently available.
+@end table
+
+If a display expression refers to local variables, then it does not make
+sense outside the lexical context for which it was set up. Such an
+expression is disabled when execution enters a context where one of its
+variables is not defined. For example, if you give the command
+@code{display last_char} while inside a function with an argument
+@code{last_char}, then this argument will be displayed while the program
+continues to stop inside that function. When it stops elsewhere---where
+there is no variable @code{last_char}---display is disabled. The next time
+your program stops where @code{last_char} is meaningful, you can enable the
+display expression once again.
+
+@node Print Settings, Value History, Auto Display, Data
+@section Print Settings
+
+@cindex format options
+@cindex print settings
+_GDBN__ provides the following ways to control how arrays, structures,
+and symbols are printed.
+
+@noindent
+These settings are useful for debugging programs in any language:
+
+@table @code
+@item set print address
+@item set print address on
+@kindex set print address
+_GDBN__ will print memory addresses showing the location of stack
+traces, structure values, pointer values, breakpoints, and so forth,
+even when it also displays the contents of those addresses. The default
+is on. For example, this is what a stack frame display looks like, with
+@code{set print address on}:
+@smallexample
+(_GDBP__) f
+#0 set_quotes (lq=0x34c78 "<<", rq=0x34c88 ">>")
+ at input.c:530
+530 if (lquote != def_lquote)
+@end smallexample
+
+@item set print address off
+Do not print addresses when displaying their contents. For example,
+this is the same stack frame displayed with @code{set print address off}:
+@example
+(_GDBP__) set print addr off
+(_GDBP__) f
+#0 set_quotes (lq="<<", rq=">>") at input.c:530
+530 if (lquote != def_lquote)
+@end example
+
+@item show print address
+@kindex show print address
+Show whether or not addresses are to be printed.
+
+@item set print array
+@itemx set print array on
+@kindex set print array
+_GDBN__ will pretty print arrays. This format is more convenient to read,
+but uses more space. The default is off.
+
+@item set print array off.
+Return to compressed format for arrays.
+
+@item show print array
+@kindex show print array
+Show whether compressed or pretty format is selected for displaying
+arrays.
+
+@item set print elements @var{number-of-elements}
+@kindex set print elements
+If _GDBN__ is printing a large array, it will stop printing after it has
+printed the number of elements set by the @code{set print elements} command.
+This limit also applies to the display of strings.
+
+@item show print elements
+@kindex show print elements
+Display the number of elements of a large array that _GDBN__ will print
+before losing patience.
+
+@item set print pretty on
+@kindex set print pretty
+Cause _GDBN__ to print structures in an indented format with one member per
+line, like this:
+
+@example
+$1 = @{
+ next = 0x0,
+ flags = @{
+ sweet = 1,
+ sour = 1
+ @},
+ meat = 0x54 "Pork"
+@}
+@end example
+
+@item set print pretty off
+Cause _GDBN__ to print structures in a compact format, like this:
+
+@smallexample
+$1 = @{next = 0x0, flags = @{sweet = 1, sour = 1@}, meat \
+= 0x54 "Pork"@}
+@end smallexample
+
+@noindent
+This is the default format.
+
+@item show print pretty
+@kindex show print pretty
+Show which format _GDBN__ will use to print structures.
+
+@item set print sevenbit-strings on
+Print using only seven-bit characters; if this option is set,
+_GDBN__ will display any eight-bit characters (in strings or character
+values) using the notation @code{\}@var{nnn}. For example, @kbd{M-a} is
+displayed as @code{\341}.
+
+@item set print sevenbit-strings off
+Print using either seven-bit or eight-bit characters, as required. This
+is the default.
+
+@item show print sevenbit-strings
+Show whether or not _GDBN__ will print only seven-bit characters.
+
+@item set print union on
+@kindex set print union
+Tell _GDBN__ to print unions which are contained in structures. This is the
+default setting.
+
+@item set print union off
+Tell _GDBN__ not to print unions which are contained in structures.
+
+@item show print union
+@kindex show print union
+Ask _GDBN__ whether or not it will print unions which are contained in
+structures.
+
+For example, given the declarations
+
+@smallexample
+typedef enum @{Tree, Bug@} Species;
+typedef enum @{Big_tree, Acorn, Seedling@} Tree_forms;
+typedef enum @{Caterpillar, Cocoon, Butterfly@} Bug_forms;
+
+struct thing @{
+ Species it;
+ union @{
+ Tree_forms tree;
+ Bug_forms bug;
+ @} form;
+@};
+
+struct thing foo = @{Tree, @{Acorn@}@};
+@end smallexample
+
+@noindent
+with @code{set print union on} in effect @samp{p foo} would print
+
+@smallexample
+$1 = @{it = Tree, form = @{tree = Acorn, bug = Cocoon@}@}
+@end smallexample
+
+@noindent
+and with @code{set print union off} in effect it would print
+
+@smallexample
+$1 = @{it = Tree, form = @{...@}@}
+@end smallexample
+@end table
+
+@noindent
+These settings are of interest when debugging C++ programs:
+
+@table @code
+@item set print demangle
+@itemx set print demangle on
+@kindex set print demangle
+Print C++ names in their source form rather than in the mangled form
+in which they are passed to the assembler and linker for type-safe linkage.
+The default is on.
+
+@item show print demangle
+@kindex show print demangle
+Show whether C++ names will be printed in mangled or demangled form.
+
+@item set print asm-demangle
+@itemx set print asm-demangle on
+@kindex set print asm-demangle
+Print C++ names in their source form rather than their mangled form, even
+in assembler code printouts such as instruction disassemblies.
+The default is off.
+
+@item show print asm-demangle
+@kindex show print asm-demangle
+Show whether C++ names in assembly listings will be printed in mangled
+or demangled form.
+
+@item set print object
+@itemx set print object on
+@kindex set print object
+When displaying a pointer to an object, identify the @emph{actual}
+(derived) type of the object rather than the @emph{declared} type, using
+the virtual function table.
+
+@item set print object off
+Display only the declared type of objects, without reference to the
+virtual function table. This is the default setting.
+
+@item show print object
+@kindex show print object
+Show whether actual, or declared, object types will be displayed.
+
+@item set print vtbl
+@itemx set print vtbl on
+@kindex set print vtbl
+Pretty print C++ virtual function tables. The default is off.
+
+@item set print vtbl off
+Do not pretty print C++ virtual function tables.
+
+@item show print vtbl
+@kindex show print vtbl
+Show whether C++ virtual function tables are pretty printed, or not.
+
+@end table
+
+@node Value History, Convenience Vars, Print Settings, Data
+@section Value History
+
+@cindex value history
+Values printed by the @code{print} command are saved in _GDBN__'s @dfn{value
+history} so that you can refer to them in other expressions. Values are
+kept until the symbol table is re-read or discarded (for example with
+the @code{file} or @code{symbol-file} commands). When the symbol table
+changes, the value history is discarded, since the values may contain
+pointers back to the types defined in the symbol table.
+
+@cindex @code{$}
+@cindex @code{$$}
+@cindex history number
+The values printed are given @dfn{history numbers} for you to refer to them
+by. These are successive integers starting with one. @code{print} shows you
+the history number assigned to a value by printing @samp{$@var{num} = }
+before the value; here @var{num} is the history number.
+
+To refer to any previous value, use @samp{$} followed by the value's
+history number. The way @code{print} labels its output is designed to
+remind you of this. Just @code{$} refers to the most recent value in
+the history, and @code{$$} refers to the value before that.
+@code{$$@var{n}} refers to the @var{n}th value from the end; @code{$$2}
+is the value just prior to @code{$$}, @code{$$1} is equivalent to
+@code{$$}, and @code{$$0} is equivalent to @code{$}.
+
+For example, suppose you have just printed a pointer to a structure and
+want to see the contents of the structure. It suffices to type
+
+@example
+p *$
+@end example
+
+If you have a chain of structures where the component @code{next} points
+to the next one, you can print the contents of the next one with this:
+
+@example
+p *$.next
+@end example
+
+@noindent
+You can print successive links in the chain by repeating this
+command---which you can do by just typing @key{RET}.
+
+Note that the history records values, not expressions. If the value of
+@code{x} is 4 and you type these commands:
+
+@example
+print x
+set x=5
+@end example
+
+@noindent
+then the value recorded in the value history by the @code{print} command
+remains 4 even though the value of @code{x} has changed.
+
+@table @code
+@kindex show values
+@item show values
+Print the last ten values in the value history, with their item numbers.
+This is like @samp{p@ $$9} repeated ten times, except that @code{show
+values} does not change the history.
+
+@item show values @var{n}
+Print ten history values centered on history item number @var{n}.
+
+@item show values +
+Print ten history values just after the values last printed. If no more
+values are available, produces no display.
+@end table
+
+Pressing @key{RET} to repeat @code{show values @var{n}} has exactly the
+same effect as @samp{show values +}.
+
+@node Convenience Vars, Registers, Value History, Data
+@section Convenience Variables
+
+@cindex convenience variables
+_GDBN__ provides @dfn{convenience variables} that you can use within
+_GDBN__ to hold on to a value and refer to it later. These variables
+exist entirely within _GDBN__; they are not part of your program, and
+setting a convenience variable has no direct effect on further execution
+of your program. That's why you can use them freely.
+
+Convenience variables are prefixed with @samp{$}. Any name preceded by
+@samp{$} can be used for a convenience variable, unless it is one of
+the predefined machine-specific register names (@pxref{Registers}).
+(Value history references, in contrast, are @emph{numbers} preceded
+by @samp{$}. @xref{Value History}.)
+
+You can save a value in a convenience variable with an assignment
+expression, just as you would set a variable in your program. Example:
+
+@example
+set $foo = *object_ptr
+@end example
+
+@noindent
+would save in @code{$foo} the value contained in the object pointed to by
+@code{object_ptr}.
+
+Using a convenience variable for the first time creates it; but its value
+is @code{void} until you assign a new value. You can alter the value with
+another assignment at any time.
+
+Convenience variables have no fixed types. You can assign a convenience
+variable any type of value, including structures and arrays, even if
+that variable already has a value of a different type. The convenience
+variable, when used as an expression, has the type of its current value.
+
+@table @code
+@item show convenience
+@kindex show convenience
+Print a list of convenience variables used so far, and their values.
+Abbreviated @code{show con}.
+@end table
+
+One of the ways to use a convenience variable is as a counter to be
+incremented or a pointer to be advanced. For example, to print
+a field from successive elements of an array of structures:
+
+_0__@example
+set $i = 0
+print bar[$i++]->contents
+@i{@dots{} repeat that command by typing @key{RET}.}
+_1__@end example
+
+Some convenience variables are created automatically by _GDBN__ and given
+values likely to be useful.
+
+@table @code
+@item $_
+The variable @code{$_} is automatically set by the @code{x} command to
+the last address examined (@pxref{Memory}). Other commands which
+provide a default address for @code{x} to examine also set @code{$_}
+to that address; these commands include @code{info line} and @code{info
+breakpoint}.
+
+@item $__
+The variable @code{$__} is automatically set by the @code{x} command
+to the value found in the last address examined.
+@end table
+
+@node Registers, Floating Point Hardware, Convenience Vars, Data
+@section Registers
+
+@cindex registers
+Machine register contents can be referred to in expressions as variables
+with names starting with @samp{$}. The names of registers are different
+for each machine; use @code{info registers} to see the names used on
+your machine.
+
+@table @code
+@item info registers
+@kindex info registers
+Print the names and values of all registers (in the selected stack frame).
+
+@item info registers @var{regname}
+Print the relativized value of register @var{regname}. @var{regname}
+may be any register name valid on the machine you are using, with
+or without the initial @samp{$}.
+@end table
+
+The register names @code{$pc} and @code{$sp} are used on most machines
+for the program counter register and the stack pointer. For example,
+you could print the program counter in hex with
+@example
+p/x $pc
+@end example
+
+@noindent
+or print the instruction to be executed next with
+@example
+x/i $pc
+@end example
+
+@noindent
+or add four to the stack pointer with
+@example
+set $sp += 4
+@end example
+
+@noindent
+The last is a way of removing one word from the stack, on machines where
+stacks grow downward in memory (most machines, nowadays). This assumes
+that the innermost stack frame is selected; setting @code{$sp} is
+not allowed when other stack frames are selected. (To pop entire frames
+off the stack, regardless of machine architecture, use @code{return};
+@pxref{Returning}.)
+
+Often @code{$fp} is used for a register that contains a pointer to the
+current stack frame, and @code{$ps} is sometimes used for a register
+that contains the processor status. These standard register names may
+be available on your machine even though the @code{info registers}
+command shows other names. For example, on the SPARC, @code{info
+registers} displays the processor status register as @code{$psr} but you
+can also refer to it as @code{$ps}.
+
+_GDBN__ always considers the contents of an ordinary register as an
+integer when the register is examined in this way. Some machines have
+special registers which can hold nothing but floating point; these
+registers are considered to have floating point values. There is no way
+to refer to the contents of an ordinary register as floating point value
+(although you can @emph{print} it as a floating point value with
+@samp{print/f $@var{regname}}).
+
+Some registers have distinct ``raw'' and ``virtual'' data formats. This
+means that the data format in which the register contents are saved by
+the operating system is not the same one that your program normally
+sees. For example, the registers of the 68881 floating point
+coprocessor are always saved in ``extended'' (raw) format, but all C
+programs expect to work with ``double'' (virtual) format. In such
+cases, _GDBN__ normally works with the virtual format only (the format that
+makes sense for your program), but the @code{info registers} command
+prints the data in both formats.
+
+Normally, register values are relative to the selected stack frame
+(@pxref{Selection}). This means that you get the value that the
+register would contain if all stack frames farther in were exited and
+their saved registers restored. In order to see the true contents of
+hardware registers, you must select the innermost frame (with
+@samp{frame 0}).
+
+However, _GDBN__ must deduce where registers are saved, from the machine
+code generated by your compiler. If some registers are not saved, or if
+_GDBN__ is unable to locate the saved registers, the selected stack
+frame will make no difference.
+
+@node Floating Point Hardware, , Registers, Data
+@section Floating Point Hardware
+@cindex floating point
+Depending on the host machine architecture, _GDBN__ may be able to give
+you more information about the status of the floating point hardware.
+
+@table @code
+@item info float
+@kindex info float
+If available, provides hardware-dependent information about the floating
+point unit. The exact contents and layout vary depending on the
+floating point chip.
+@end table
+@c FIXME: this is a cop-out. Try to get examples, explanations. Only
+@c FIXME...supported currently on arm's and 386's. Mark properly with
+@c FIXME... m4 macros to isolate general statements from hardware-dep,
+@c FIXME... at that point.
+
+@node Symbols, Altering, Data, Top
+@chapter Examining the Symbol Table
+
+The commands described in this section allow you to inquire about the
+symbols (names of variables, functions and types) defined in your
+program. This information is inherent in the text of your program and
+does not change as the program executes. _GDBN__ finds it in your
+program's symbol table, in the file indicated when you started _GDBN__
+(@pxref{File Options}), or by one of the file-management commands
+(@pxref{Files}).
+
+@table @code
+@item info address @var{symbol}
+@kindex info address
+Describe where the data for @var{symbol} is stored. For a register
+variable, this says which register it is kept in. For a non-register
+local variable, this prints the stack-frame offset at which the variable
+is always stored.
+
+Note the contrast with @samp{print &@var{symbol}}, which does not work
+at all for a register variables, and for a stack local variable prints
+the exact address of the current instantiation of the variable.
+
+@item whatis @var{exp}
+@kindex whatis
+Print the data type of expression @var{exp}. @var{exp} is not
+actually evaluated, and any side-effecting operations (such as
+assignments or function calls) inside it do not take place.
+@xref{Expressions}.
+
+@item whatis
+Print the data type of @code{$}, the last value in the value history.
+
+@item ptype @var{typename}
+@kindex ptype
+Print a description of data type @var{typename}. @var{typename} may be
+the name of a type, or for C code it may have the form
+@samp{struct @var{struct-tag}}, @samp{union @var{union-tag}} or
+@samp{enum @var{enum-tag}}.@refill
+
+@item ptype @var{exp}
+Print a description of the type of expression @var{exp}. @code{ptype}
+differs from @code{whatis} by printing a detailed description, instead of just
+the name of the type. For example, if your program declares a variable
+as
+@example
+struct complex @{double real; double imag;@} v;
+@end example
+@noindent
+compare the output of the two commands:
+@example
+(_GDBP__) whatis v
+type = struct complex
+(_GDBP__) ptype v
+type = struct complex @{
+ double real;
+ double imag;
+@}
+@end example
+
+@item info types @var{regexp}
+@itemx info types
+@kindex info types
+Print a brief description of all types whose name matches @var{regexp}
+(or all types in your program, if you supply no argument). Each
+complete typename is matched as though it were a complete line; thus,
+@samp{i type value} gives information on all types in your program whose
+name includes the string @code{value}, but @samp{i type ^value$} gives
+information only on types whose complete name is @code{value}.
+
+This command differs from @code{ptype} in two ways: first, like
+@code{whatis}, it does not print a detailed description; second, it
+lists all source files where a type is defined.
+
+@item info source
+@kindex info source
+Show the name of the current source file---that is, the source file for
+the function containing the current point of execution.
+
+@item info sources
+@kindex info sources
+Print the names of all source files in the program for which there is
+debugging information, organized into two lists: those for which symbols
+have been read in, and those for which symbols will be read in on
+demand.
+@c FIXME: above passive AND awkward!
+
+@item info functions
+@kindex info functions
+Print the names and data types of all defined functions.
+
+@item info functions @var{regexp}
+Print the names and data types of all defined functions
+whose names contain a match for regular expression @var{regexp}.
+Thus, @samp{info fun step} finds all functions whose names
+include @code{step}; @samp{info fun ^step} finds those whose names
+start with @code{step}.
+
+@item info variables
+@kindex info variables
+Print the names and data types of all variables that are declared
+outside of functions (i.e., excluding local variables).
+
+@item info variables @var{regexp}
+Print the names and data types of all variables (except for local
+variables) whose names contain a match for regular expression
+@var{regexp}.
+
+
+@ignore
+This was never implemented.
+@item info methods
+@itemx info methods @var{regexp}
+@kindex info methods
+The @code{info methods} command permits the user to examine all defined
+methods within C++ program, or (with the @var{regexp} argument) a
+specific set of methods found in the various C++ classes. Many
+C++ classes provide a large number of methods. Thus, the output
+from the @code{ptype} command can be overwhelming and hard to use. The
+@code{info-methods} command filters the methods, printing only those
+which match the regular-expression @var{regexp}.
+@end ignore
+
+@item printsyms @var{filename}
+@kindex printsyms
+Write a complete dump of the debugger's symbol data into the
+file @var{filename}.
+@end table
+
+@node Altering, _GDBN__ Files, Symbols, Top
+@chapter Altering Execution
+
+Once you think you have found an error in the program, you might want to
+find out for certain whether correcting the apparent error would lead to
+correct results in the rest of the run. You can find the answer by
+experiment, using the _GDBN__ features for altering execution of the
+program.
+
+For example, you can store new values into variables or memory
+locations, give the program a signal, restart it at a different address,
+or even return prematurely from a function to its caller.
+
+@menu
+* Assignment:: Assignment to Variables
+* Jumping:: Continuing at a Different Address
+* Signaling:: Giving the Program a Signal
+* Returning:: Returning from a Function
+* Calling:: Calling your Program's Functions
+@end menu
+
+@node Assignment, Jumping, Altering, Altering
+@section Assignment to Variables
+
+@cindex assignment
+@cindex setting variables
+To alter the value of a variable, evaluate an assignment expression.
+@xref{Expressions}. For example,
+
+@example
+print x=4
+@end example
+
+@noindent
+would store the value 4 into the variable @code{x}, and then print the
+value of the assignment expression (which is 4). All the assignment
+operators of C are supported, including the increment operators
+@samp{++} and @samp{--}, and combining assignments such as @samp{+=} and
+_0__@samp{<<=}_1__.
+
+@kindex set
+@kindex set variable
+@cindex variables, setting
+If you are not interested in seeing the value of the assignment, use the
+@code{set} command instead of the @code{print} command. @code{set} is
+really the same as @code{print} except that the expression's value is not
+printed and is not put in the value history (@pxref{Value History}). The
+expression is evaluated only for its effects.
+
+If the beginning of the argument string of the @code{set} command
+appears identical to a @code{set} subcommand, use the @code{set
+variable} command instead of just @code{set}. This command is identical
+to @code{set} except for its lack of subcommands. For example, a
+program might well have a variable @code{width}---which leads to
+an error if we try to set a new value with just @samp{set width=13}, as
+we might if @code{set width} didn't happen to be a _GDBN__ command:
+@example
+(_GDBP__) whatis width
+type = double
+(_GDBP__) p width
+$4 = 13
+(_GDBP__) set width=47
+Invalid syntax in expression.
+@end example
+@noindent
+The invalid expression, of course, is @samp{=47}. What we can do in
+order to actually set our program's variable @code{width} is
+@example
+(_GDBP__) set var width=47
+@end example
+
+_GDBN__ allows more implicit conversions in assignments than C does; you can
+freely store an integer value into a pointer variable or vice versa, and
+any structure can be converted to any other structure that is the same
+length or shorter.
+@comment FIXME: how do structs align/pad in these conversions?
+@comment /pesch@cygnus.com 18dec1990
+
+To store values into arbitrary places in memory, use the @samp{@{@dots{}@}}
+construct to generate a value of specified type at a specified address
+(@pxref{Expressions}). For example, @code{@{int@}0x83040} refers
+to memory location @code{0x83040} as an integer (which implies a certain size
+and representation in memory), and
+
+@example
+set @{int@}0x83040 = 4
+@end example
+
+@noindent
+stores the value 4 into that memory location.
+
+@node Jumping, Signaling, Assignment, Altering
+@section Continuing at a Different Address
+
+Ordinarily, when you continue the program, you do so at the place where
+it stopped, with the @code{continue} command. You can instead continue at
+an address of your own choosing, with the following commands:
+
+@table @code
+@item jump @var{linespec}
+@kindex jump
+Resume execution at line @var{linespec}. Execution will stop
+immediately if there is a breakpoint there. @xref{List} for a
+description of the different forms of @var{linespec}.
+
+The @code{jump} command does not change the current stack frame, or
+the stack pointer, or the contents of any memory location or any
+register other than the program counter. If line @var{linespec} is in
+a different function from the one currently executing, the results may
+be bizarre if the two functions expect different patterns of arguments or
+of local variables. For this reason, the @code{jump} command requests
+confirmation if the specified line is not in the function currently
+executing. However, even bizarre results are predictable if you are
+well acquainted with the machine-language code of the program.
+
+@item jump *@var{address}
+Resume execution at the instruction at address @var{address}.
+@end table
+
+You can get much the same effect as the @code{jump} command by storing a
+new value into the register @code{$pc}. The difference is that this
+does not start the program running; it only changes the address where it
+@emph{will} run when it is continued. For example,
+
+@example
+set $pc = 0x485
+@end example
+
+@noindent
+causes the next @code{continue} command or stepping command to execute at
+address 0x485, rather than at the address where the program stopped.
+@xref{Stepping}.
+
+The most common occasion to use the @code{jump} command is to back up,
+perhaps with more breakpoints set, over a portion of a program that has
+already executed, in order to examine its execution in more detail.
+
+@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{Stepping})
+resumes execution until the selected stack frame returns naturally.
+
+@node Calling, , Returning, Altering
+@section Calling your Program's Functions
+
+@cindex calling functions
+@kindex call
+@table @code
+@item call @var{expr}
+Evaluate the expression @var{expr} without displaying @code{void}
+returned values.
+@end table
+
+You can use this variant of the @code{print} command if you want to
+execute a function from your program, but without cluttering the output
+with @code{void} returned values. The result is printed and saved in
+the value history, if it is not void.
+
+@node _GDBN__ Files, Targets, Altering, Top
+@chapter _GDBN__'s Files
+
+@menu
+* Files:: Commands to Specify Files
+* Symbol Errors:: Errors Reading Symbol Files
+@end menu
+
+@node Files, Symbol Errors, _GDBN__ Files, _GDBN__ Files
+@section Commands to Specify Files
+@cindex core dump file
+@cindex symbol table
+_GDBN__ needs to know the file name of the program to be debugged, both in
+order to read its symbol table and in order to start the program. To
+debug a core dump of a previous run, _GDBN__ must be told the file name of
+the core dump.
+
+The usual way to specify the executable and core dump file names is with
+the command arguments given when you start _GDBN__, as discussed in
+@pxref{Invocation}.
+
+Occasionally it is necessary to change to a different file during a
+_GDBN__ session. Or you may run _GDBN__ and forget to specify the files you
+want to use. In these situations the _GDBN__ commands to specify new files
+are useful.
+
+@table @code
+@item file @var{filename}
+@cindex executable file
+@kindex file
+Use @var{filename} as the program to be debugged. It is read for its
+symbols and for the contents of pure memory. It is also the program
+executed when you use the @code{run} command. If you do not specify a
+directory and the file is not found in _GDBN__'s working directory,
+
+_GDBN__ uses the environment variable @code{PATH} as a list of
+directories to search, just as the shell does when looking for a program
+to run. You can change the value of this variable, for both _GDBN__ and
+your program, using the @code{path} command.
+
+@code{file} with no argument makes _GDBN__ discard any information it
+has on both executable file and the symbol table.
+
+@item exec-file @var{filename}
+@kindex exec-file
+Specify that the program to be run (but not the symbol table) is found
+in @var{filename}. _GDBN__ will search the environment variable @code{PATH}
+if necessary to locate the program.
+
+@item symbol-file @var{filename}
+@kindex symbol-file
+Read symbol table information from file @var{filename}. @code{PATH} is
+searched when necessary. Use the @code{file} command to get both symbol
+table and program to run from the same file.
+
+@code{symbol-file} with no argument clears out _GDBN__'s information on your
+program's symbol table.
+
+The @code{symbol-file} command causes _GDBN__ to forget the contents of its
+convenience variables, the value history, and all breakpoints and
+auto-display expressions. This is because they may contain pointers to
+the internal data recording symbols and data types, which are part of
+the old symbol table data being discarded inside _GDBN__.
+
+@code{symbol-file} will not repeat if you press @key{RET} again after
+executing it once.
+
+On some kinds of object files, the @code{symbol-file} command does not
+actually read the symbol table in full right away. Instead, it scans
+the symbol table quickly to find which source files and which symbols
+are present. The details are read later, one source file at a time,
+when they are needed.
+
+The purpose of this two-stage reading strategy is to make _GDBN__ start up
+faster. For the most part, it is invisible except for occasional pauses
+while the symbol table details for a particular source file are being
+read. (The @code{set verbose} command can turn these pauses into
+messages if desired. @xref{Messages/Warnings}).
+
+When the symbol table is stored in COFF format, @code{symbol-file} does
+read the symbol table data in full right away. We haven't implemented
+the two-stage strategy for COFF yet.
+
+When _GDBN__ is configured for a particular environment, it will
+understand debugging information in whatever format is the standard
+generated for that environment; you may use either a GNU compiler, or
+other compilers that adhere to the local conventions. Best results are
+usually obtained from GNU compilers; for example, using @code{_GCC__}
+you can generate debugging information for optimized code.
+
+@item core-file @var{filename}
+@itemx core @var{filename}
+@kindex core
+@kindex core-file
+Specify the whereabouts of a core dump file to be used as the ``contents
+of memory''. Traditionally, core files contain only some parts of the
+address space of the process that generated them; _GDBN__ can access the
+executable file itself for other parts.
+
+@code{core-file} with no argument specifies that no core file is
+to be used.
+
+Note that the core file is ignored when your program is actually running
+under _GDBN__. So, if you have been running the program and you wish to
+debug a core file instead, you must kill the subprocess in which the
+program is running. To do this, use the @code{kill} command
+(@pxref{Kill Process}).
+
+@item load @var{filename}
+@kindex load
+_if__(_GENERIC__)
+Depending on what remote debugging facilities are configured into
+_GDBN__, the @code{load} command may be available. Where it exists, it
+is meant to make @var{filename} (an executable) available for debugging
+on the remote system---by downloading, or dynamic linking, for example.
+@code{load} also records @var{filename}'s symbol table in _GDBN__, like
+the @code{add-symbol-file} command.
+
+If @code{load} is not available on your _GDBN__, attempting to execute
+it gets the error message ``@code{You can't do that when your target is
+@dots{}}''
+_fi__(_GENERIC__)
+
+_if__(_VXWORKS__)
+On VxWorks, @code{load} will dynamically link @var{filename} on the
+current target system as well as adding its symbols in _GDBN__.
+_fi__(_VXWORKS__)
+
+_if__(_I960__)
+@cindex download to Nindy-960
+With the Nindy interface to an Intel 960 board, @code{load} will
+download @var{filename} to the 960 as well as adding its symbols in
+_GDBN__.
+_fi__(_I960__)
+
+@code{load} will not repeat if you press @key{RET} again after using it.
+
+@item add-symbol-file @var{filename} @var{address}
+@kindex add-symbol-file
+@cindex dynamic linking
+The @code{add-symbol-file} command reads additional symbol table information
+from the file @var{filename}. You would use this command when that file
+has been dynamically loaded (by some other means) into the program that
+is running. @var{address} should be the memory address at which the
+file has been loaded; _GDBN__ cannot figure this out for itself.
+
+The symbol table of the file @var{filename} is added to the symbol table
+originally read with the @code{symbol-file} command. You can use the
+@code{add-symbol-file} command any number of times; the new symbol data thus
+read keeps adding to the old. To discard all old symbol data instead,
+use the @code{symbol-file} command.
+
+@code{add-symbol-file} will not repeat if you press @key{RET} after using it.
+
+@item info files
+@itemx info target
+@kindex info files
+@kindex info target
+@code{info files} and @code{info target} are synonymous; both print the
+current targets (@pxref{Targets}), including the names of the executable
+and core dump files currently in use by _GDBN__, and the files from
+which symbols were loaded. The command @code{help targets} lists all
+possible targets rather than current ones.
+
+@end table
+
+All file-specifying commands allow both absolute and relative file names
+as arguments. _GDBN__ always converts the file name to an absolute path
+name and remembers it that way.
+
+@kindex sharedlibrary
+@kindex share
+@cindex shared libraries
+
+_GDBN__ supports the SunOS shared library format. Symbols from a shared
+library cannot be referenced before the shared library has been linked
+with the program. (That is to say, until after you type @code{run} and
+the function @code{main} has been entered; or when examining core
+files.) Once the shared library has been linked in, you can use the
+following commands:
+
+@table @code
+@item sharedlibrary @var{regex}
+@itemx share @var{regex}
+Load shared object library symbols for files matching a UNIX regular
+expression.
+
+@item share
+@itemx sharedlibrary
+Load symbols for all shared libraries.
+
+@item info share
+@itemx info sharedlibrary
+@kindex info sharedlibrary
+@kindex info share
+Print the names of the shared libraries which you have loaded with the
+@code{sharedlibrary} command.
+@end table
+
+@code{sharedlibrary} does not repeat automatically when you press
+@key{RET} after using it once.
+
+@node Symbol Errors, , Files, _GDBN__ Files
+@section Errors Reading Symbol Files
+While a symbol file is being read, _GDBN__ will occasionally encounter
+problems, such as symbol types it does not recognize, or known bugs in
+compiler output. By default, it prints one message about each such
+type of problem, no matter how many times the problem occurs. You can
+ask it to print more messages, to see how many times the problems occur,
+or can shut the messages off entirely, with the @code{set
+complaints} command (@xref{Messages/Warnings}).
+
+The messages currently printed, and their meanings, are:
+
+@table @code
+@item inner block not inside outer block in @var{symbol}
+
+The symbol information shows where symbol scopes begin and end
+(such as at the start of a function or a block of statements). This
+error indicates that an inner scope block is not fully contained
+in its outer scope blocks.
+
+_GDBN__ circumvents the problem by treating the inner block as if it had
+the same scope as the outer block. In the error message, @var{symbol}
+may be shown as ``@code{(don't know)}'' if the outer block is not a
+function.
+
+@item block at @var{address} out of order
+
+The symbol information for symbol scope blocks should occur in
+order of increasing addresses. This error indicates that it does not
+do so.
+
+_GDBN__ does not circumvent this problem, and will have trouble locating
+symbols in the source file whose symbols being read. (You can often
+determine what source file is affected by specifying @code{set verbose
+on}. @xref{Messages/Warnings}.)
+
+@item bad block start address patched
+
+The symbol information for a symbol scope block has a start address
+smaller than the address of the preceding source line. This is known
+to occur in the SunOS 4.1.1 (and earlier) C compiler.
+
+_GDBN__ circumvents the problem by treating the symbol scope block as
+starting on the previous source line.
+
+@c @item{encountered DBX-style class variable debugging information.
+@c You seem to have compiled your program with "g++ -g0" instead of "g++ -g".
+@c Therefore _GDBN__ will not know about your class variables}
+@c
+@c This error indicates that the symbol information produced for a C++
+@c program includes zero-size fields, which indicated static fields in
+@c a previous release of the G++ compiler. This message is probably
+@c obsolete.
+@c
+@item bad string table offset in symbol @var{n}
+
+@cindex foo
+Symbol number @var{n} contains a pointer into the string table which is
+larger than the size of the string table.
+
+_GDBN__ circumvents the problem by considering the symbol to have the
+name @code{foo}, which may cause other problems if many symbols end up
+with this name.
+
+@item unknown symbol type @code{0x@var{nn}}
+
+The symbol information contains new data types that _GDBN__ does not yet
+know how to read. @code{0x@var{nn}} is the symbol type of the misunderstood
+information, in hexadecimal.
+
+_GDBN__ circumvents the error by ignoring this symbol information. This
+will usually allow the program to be debugged, though certain symbols
+will not be accessible. If you encounter such a problem and feel like
+debugging it, you can debug @code{_GDBP__} with itself, breakpoint on
+@code{complain}, then go up to the function @code{read_dbx_symtab} and
+examine @code{*bufp} to see the symbol.
+
+@item stub type has NULL name
+_GDBN__ could not find the full definition for a struct or class.
+
+@ignore
+@c this is #if 0'd in dbxread.c as of (at least!) 17 may 1991
+@item const/volatile indicator missing, got '@var{X}'
+
+The symbol information for a C++ member function is missing some
+information that the compiler should have output for it.
+@end ignore
+
+@item C++ type mismatch between compiler and debugger
+
+The debugger could not parse a type specification output by the compiler
+for some C++ object.
+
+@end table
+
+@node Targets, Controlling _GDBN__, _GDBN__ Files, Top
+@chapter Specifying a Debugging Target
+@cindex debugging target
+@kindex target
+A @dfn{target} is an interface between the debugger and a particular
+kind of file or process.
+
+Often, you will be able to run _GDBN__ in the same host environment as the
+program you are debugging; in that case, the debugging target can just be
+specified as a side effect of the @code{file} or @code{core} commands.
+When you need more flexibility---for example, running _GDBN__ on a
+physically separate host, controlling standalone systems over a
+serial port, or realtime systems over a TCP/IP connection---you can use
+the @code{target} command.
+
+@menu
+* Active Targets:: Active Targets
+* Target Commands:: Commands for Managing Targets
+* Remote:: Remote Debugging
+@end menu
+
+@node Active Targets, Target Commands, Targets, Targets
+@section Active Targets
+@cindex stacking targets
+@cindex active targets
+@cindex multiple targets
+
+Targets are managed in three @dfn{strata} that correspond to different
+classes of target: processes, core files, and executable files. This
+allows you to (for example) start a process and inspect its activity
+without abandoning your work on a core file.
+
+More than one target can potentially respond to a request. In
+particular, when you access memory _GDBN__ will examine the three strata of
+targets until it finds a target that can handle that particular address.
+Strata are always examined in a fixed order: first a process if there is
+one, then a core file if there is one, and finally an executable file if
+there is one of those.
+
+When you specify a new target in a given stratum, it replaces any target
+previously in that stratum.
+
+To get rid of a target without replacing it, use the @code{detach}
+command. The related command @code{attach} provides you with a way of
+choosing a particular running process as a new target. @xref{Attach}.
+
+@node Target Commands, Remote, Active Targets, Targets
+@section Commands for Managing Targets
+
+@table @code
+@item target @var{type} @var{parameters}
+Connects the _GDBN__ host environment to a target machine or process. A
+target is typically a protocol for talking to debugging facilities. You
+use the argument @var{type} to specify the type or protocol of the
+target machine.
+
+Further @var{parameters} are interpreted by the target protocol, but
+typically include things like device names or host names to connect
+with, process numbers, and baud rates.
+
+The @code{target} command will not repeat if you press @key{RET} again
+after executing the command.
+
+@item help target
+@kindex help target
+Displays the names of all targets available. To display targets
+currently selected, use either @code{info target} or @code{info files}
+(@pxref{Files}).
+
+@item help target @var{name}
+Describe a particular target, including any parameters necessary to
+select it.
+@end table
+
+Here are some common targets (available, or not, depending on the _GDBN__
+configuration):
+
+@table @code
+@item target exec @var{prog}
+@kindex target exec
+An executable file. @samp{target exec @var{prog}} is the same as
+@samp{exec-file @var{prog}}.
+
+@item target core @var{filename}
+@kindex target core
+A core dump file. @samp{target core @var{filename}} is the same as
+@samp{core-file @var{filename}}.
+
+@item target remote @var{dev}
+@kindex target remote
+Remote serial target in _GDBN__-specific protocol. The argument @var{dev}
+specifies what serial device to use for the connection (e.g.
+@file{/dev/ttya}). @xref{Remote}.
+
+_if__(_AMD29K__)
+@item target amd-eb @var{dev} @var{speed} @var{PROG}
+@kindex target amd-eb
+@cindex AMD EB29K
+Remote PC-resident AMD EB29K board, attached over serial lines.
+@var{dev} is the serial device, as for @code{target remote};
+@var{speed} allows you to specify the linespeed; and @var{PROG} is the
+name of the program to be debugged, as it appears to DOS on the PC.
+@xref{EB29K Remote}.
+
+_fi__(_AMD29K__)
+_if__(_I960__)
+@item target nindy @var{devicename}
+@kindex target nindy
+An Intel 960 board controlled by a Nindy Monitor. @var{devicename} is
+the name of the serial device to use for the connection, e.g.
+@file{/dev/ttya}. @xref{i960-Nindy Remote}.
+
+_fi__(_I960__)
+_if__(_VXWORKS__)
+@item target vxworks @var{machinename}
+@kindex target vxworks
+A VxWorks system, attached via TCP/IP. The argument @var{machinename}
+is the target system's machine name or IP address.
+@xref{VxWorks Remote}.
+_fi__(_VXWORKS__)
+@end table
+
+_if__(_GENERIC__)
+Different targets are available on different configurations of _GDBN__; your
+configuration may have more or fewer targets.
+_fi__(_GENERIC__)
+
+@node Remote, , Target Commands, Targets
+@section Remote Debugging
+@cindex remote debugging
+
+_if__(_GENERIC__)
+@menu
+_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 8, 10, 16. @var{base} must itself be
+specified either unambiguously or using the current default radix; for
+example, any of
+
+@example
+set radix 012
+set radix 10.
+set radix 0xa
+@end example
+
+@noindent
+will set the base to decimal. On the other hand, @samp{set radix 10}
+will leave the radix unchanged no matter what it was.
+
+@kindex show radix
+@item show radix
+Display the current default base for numeric input and display.
+
+@end table
+
+@node Messages/Warnings, , Numbers, Controlling _GDBN__
+@section Optional Warnings and Messages
+By default, _GDBN__ is silent about its inner workings. If you are running
+on a slow machine, you may want to use the @code{set verbose} command.
+It will make _GDBN__ tell you when it does a lengthy internal operation, so
+you won't think it has crashed.
+
+Currently, the messages controlled by @code{set verbose} are those which
+announce that the symbol table for a source file is being read
+(@pxref{Files}, in the description of the command
+@code{symbol-file}).
+@c The following is the right way to do it, but emacs 18.55 doesn't support
+@c @ref, and neither the emacs lisp manual version of texinfmt or makeinfo
+@c is released.
+@ignore
+see @code{symbol-file} in @ref{Files}).
+@end ignore
+
+@table @code
+@kindex set verbose
+@item set verbose on
+Enables _GDBN__'s output of certain informational messages.
+
+@item set verbose off
+Disables _GDBN__'s output of certain informational messages.
+
+@kindex show verbose
+@item show verbose
+Displays whether @code{set verbose} is on or off.
+@end table
+
+By default, if _GDBN__ encounters bugs in the symbol table of an object file,
+it prints a single message about each type of problem it finds, then
+shuts up (@pxref{Symbol Errors}). You can suppress these messages, or allow more than one such
+message to be printed if you want to see how frequent the problems are.
+
+@table @code
+@kindex set complaints
+@item set complaints @var{limit}
+Permits _GDBN__ to output @var{limit} complaints about each type of unusual
+symbols before becoming silent about the problem. Set @var{limit} to
+zero to suppress all complaints; set it to a large number to prevent
+complaints from being suppressed.
+
+@kindex show complaints
+@item show complaints
+Displays how many symbol complaints _GDBN__ is permitted to produce.
+@end table
+
+By default, _GDBN__ is cautious, and asks what sometimes seem to be a
+lot of stupid questions to confirm certain commands. For example, if
+you try to run a program which is already running:
+@example
+(_GDBP__) run
+The program being debugged has been started already.
+Start it from the beginning? (y or n)
+@end example
+
+If you're willing to unflinchingly face the consequences of your own
+commands, you can disable this ``feature'':
+
+@table @code
+@kindex set confirm
+@cindex flinching
+@cindex confirmation
+@cindex stupid questions
+@item set confirm off
+Disables confirmation requests.
+
+@item set confirm on
+Enables confirmation requests (the default).
+
+@item show confirm
+@kindex show confirm
+Displays state of confirmation requests.
+@end table
+
+@node Sequences, Emacs, Controlling _GDBN__, Top
+@chapter Canned Sequences of Commands
+
+Aside from breakpoint commands (@pxref{Break Commands}), _GDBN__ provides two
+ways to store sequences of commands for execution as a unit:
+user-defined commands and command files.
+
+@menu
+* Define:: User-Defined Commands
+* Command Files:: Command Files
+* Output:: Commands for Controlled Output
+@end menu
+
+@node Define, Command Files, Sequences, Sequences
+@section User-Defined Commands
+
+@cindex user-defined command
+A @dfn{user-defined command} is a sequence of _GDBN__ commands to which you
+assign a new name as a command. This is done with the @code{define}
+command.
+
+@table @code
+@item define @var{commandname}
+@kindex define
+Define a command named @var{commandname}. If there is already a command
+by that name, you are asked to confirm that you want to redefine it.
+
+The definition of the command is made up of other _GDBN__ command lines,
+which are given following the @code{define} command. The end of these
+commands is marked by a line containing @code{end}.
+
+@item document @var{commandname}
+@kindex document
+Give documentation to the user-defined command @var{commandname}. The
+command @var{commandname} must already be defined. This command reads
+lines of documentation just as @code{define} reads the lines of the
+command definition, ending with @code{end}. After the @code{document}
+command is finished, @code{help} on command @var{commandname} will print
+the documentation you have specified.
+
+You may use the @code{document} command again to change the
+documentation of a command. Redefining the command with @code{define}
+does not change the documentation.
+
+@item help user-defined
+@kindex help user-defined
+List all user-defined commands, with the first line of the documentation
+(if any) for each.
+
+@item info user
+@itemx info user @var{commandname}
+@kindex info user
+Display the _GDBN__ commands used to define @var{commandname} (but not its
+documentation). If no @var{commandname} is given, display the
+definitions for all user-defined commands.
+@end table
+
+User-defined commands do not take arguments. When they are executed, the
+commands of the definition are not printed. An error in any command
+stops execution of the user-defined command.
+
+Commands that would ask for confirmation if used interactively proceed
+without asking when used inside a user-defined command. Many _GDBN__ commands
+that normally print messages to say what they are doing omit the messages
+when used in a user-defined command.
+
+@node Command Files, Output, Define, Sequences
+@section Command Files
+
+@cindex command files
+A command file for _GDBN__ is a file of lines that are _GDBN__ commands. Comments
+(lines starting with @kbd{#}) may also be included. An empty line in a
+command file does nothing; it does not mean to repeat the last command, as
+it would from the terminal.
+
+@cindex init file
+@cindex @file{_GDBINIT__}
+When you start _GDBN__, it automatically executes commands from its
+@dfn{init files}. These are files named @file{_GDBINIT__}. _GDBN__
+reads the init file (if any) in your home directory and then the init
+file (if any) in the current working directory. (The init files are not
+executed if you use the @samp{-nx} option; @pxref{Mode Options}.) You
+can also request the execution of a command file with the @code{source}
+command:
+
+@table @code
+@item source @var{filename}
+@kindex source
+Execute the command file @var{filename}.
+@end table
+
+The lines in a command file are executed sequentially. They are not
+printed as they are executed. An error in any command terminates execution
+of the command file.
+
+Commands that would ask for confirmation if used interactively proceed
+without asking when used in a command file. Many _GDBN__ commands that
+normally print messages to say what they are doing omit the messages
+when called from command files.
+
+@node Output, , Command Files, Sequences
+@section Commands for Controlled Output
+
+During the execution of a command file or a user-defined command, normal
+_GDBN__ output is suppressed; the only output that appears is what is
+explicitly printed by the commands in the definition. This section
+describes three commands useful for generating exactly the output you
+want.
+
+@table @code
+@item echo @var{text}
+@kindex echo
+@c I don't consider backslash-space a standard C escape sequence
+@c because it's not in ANSI.
+Print @var{text}. Nonprinting characters can be included in @var{text}
+using C escape sequences, such as @samp{\n} to print a newline. @b{No
+newline will be printed unless you specify one.} In addition to the
+standard C escape sequences, a backslash followed by a space stands for a
+space. This is useful for outputting a string with spaces at the
+beginning or the end, since leading and trailing spaces are otherwise
+trimmed from all arguments. Thus, to print @samp{@ and foo =@ }, use the
+command @samp{echo \@ and foo = \@ }.
+@c FIXME: verify hard copy actually issues enspaces for '@ '! Will this
+@c confuse texinfo?
+
+A backslash at the end of @var{text} can be used, as in C, to continue
+the command onto subsequent lines. For example,
+
+@example
+echo This is some text\n\
+which is continued\n\
+onto several lines.\n
+@end example
+
+produces the same output as
+
+@example
+echo This is some text\n
+echo which is continued\n
+echo onto several lines.\n
+@end example
+
+@item output @var{expression}
+@kindex output
+Print the value of @var{expression} and nothing but that value: no
+newlines, no @samp{$@var{nn} = }. The value is not entered in the
+value history either. @xref{Expressions} for more information on
+expressions.
+
+@item output/@var{fmt} @var{expression}
+Print the value of @var{expression} in format @var{fmt}. You can use
+the same formats as for @code{print}; @pxref{Output formats}, for more
+information.
+
+@item printf @var{string}, @var{expressions}@dots{}
+@kindex printf
+Print the values of the @var{expressions} under the control of
+@var{string}. The @var{expressions} are separated by commas and may
+be either numbers or pointers. Their values are printed as specified
+by @var{string}, exactly as if the program were to execute
+
+@example
+printf (@var{string}, @var{expressions}@dots{});
+@end example
+
+For example, you can print two values in hex like this:
+
+@example
+printf "foo, bar-foo = 0x%x, 0x%x\n", foo, bar-foo
+@end example
+
+The only backslash-escape sequences that you can use in the format
+string are the simple ones that consist of backslash followed by a
+letter.
+@end table
+
+@node Emacs, _GDBN__ Bugs, Sequences, Top
+@chapter Using _GDBN__ under GNU Emacs
+
+@cindex emacs
+A special interface allows you to use GNU Emacs to view (and
+edit) the source files for the program you are debugging with
+_GDBN__.
+
+To use this interface, use the command @kbd{M-x gdb} in Emacs. Give the
+executable file you want to debug as an argument. This command starts
+_GDBN__ as a subprocess of Emacs, with input and output through a newly
+created Emacs buffer.
+
+Using _GDBN__ under Emacs is just like using _GDBN__ normally except for two
+things:
+
+@itemize @bullet
+@item
+All ``terminal'' input and output goes through the Emacs buffer.
+@end itemize
+
+This applies both to _GDBN__ commands and their output, and to the input
+and output done by the program you are debugging.
+
+This is useful because it means that you can copy the text of previous
+commands and input them again; you can even use parts of the output
+in this way.
+
+All the facilities of Emacs' Shell mode are available for this purpose.
+
+@itemize @bullet
+@item
+_GDBN__ displays source code through Emacs.
+@end itemize
+
+Each time _GDBN__ displays a stack frame, Emacs automatically finds the
+source file for that frame and puts an arrow (_0__@samp{=>}_1__) at the
+left margin of the current line. Emacs uses a separate buffer for
+source display, and splits the window to show both your _GDBN__ session
+and the source.
+
+Explicit _GDBN__ @code{list} or search commands still produce output as
+usual, but you probably will have no reason to use them.
+
+@quotation
+@emph{Warning:} If the directory where your program resides is not your
+current directory, it can be easy to confuse Emacs about the location of
+the source files, in which case the auxiliary display buffer will not
+appear to show your source. _GDBN__ can find programs by searching your
+environment's @code{PATH} variable, so the _GDBN__ input and output
+session will proceed normally; but Emacs doesn't get enough information
+back from _GDBN__ to locate the source files in this situation. To
+avoid this problem, either start _GDBN__ mode from the directory where
+your program resides, or specify a full path name when prompted for the
+@kbd{M-x gdb} argument.
+
+A similar confusion can result if you use the _GDBN__ @code{file} command to
+switch to debugging a program in some other location, from an existing
+_GDBN__ buffer in Emacs.
+@end quotation
+
+By default, @kbd{M-x gdb} calls the program called @file{gdb}. If
+you need to call _GDBN__ by a different name (for example, if you keep
+several configurations around, with different names) you can set the
+Emacs variable @code{gdb-command-name}; for example,
+@example
+(setq gdb-command-name "mygdb")
+@end example
+@noindent
+(preceded by @kbd{ESC ESC}, or typed in the @code{*scratch*} buffer, or
+in your @file{.emacs} file) will make Emacs call the program named
+``@code{mygdb}'' instead.
+
+In the _GDBN__ I/O buffer, you can use these special Emacs commands in
+addition to the standard Shell mode commands:
+
+@table @kbd
+@item C-h m
+Describe the features of Emacs' _GDBN__ Mode.
+
+@item M-s
+Execute to another source line, like the _GDBN__ @code{step} command; also
+update the display window to show the current file and location.
+
+@item M-n
+Execute to next source line in this function, skipping all function
+calls, like the _GDBN__ @code{next} command. Then update the display window
+to show the current file and location.
+
+@item M-i
+Execute one instruction, like the _GDBN__ @code{stepi} command; update
+display window accordingly.
+
+@item M-x gdb-nexti
+Execute to next instruction, using the _GDBN__ @code{nexti} command; update
+display window accordingly.
+
+@item C-c C-f
+Execute until exit from the selected stack frame, like the _GDBN__
+@code{finish} command.
+
+@item M-c
+Continue execution of the program, like the _GDBN__ @code{continue}
+command. @emph{Warning:} In Emacs v19, this command is @kbd{C-c C-p}.
+
+@item M-u
+Go up the number of frames indicated by the numeric argument
+(@pxref{Arguments, , Numeric Arguments, emacs, The GNU Emacs Manual}),
+like the _GDBN__ @code{up} command. @emph{Warning:} In Emacs v19, this
+command is @kbd{C-c C-u}.@refill
+
+@item M-d
+Go down the number of frames indicated by the numeric argument, like the
+_GDBN__ @code{down} command. @emph{Warning:} In Emacs v19, this command
+is @kbd{C-c C-d}.
+
+@item C-x &
+Read the number where the cursor is positioned, and insert it at the end
+of the _GDBN__ I/O buffer. For example, if you wish to disassemble code
+around an address that was displayed earlier, type @kbd{disassemble};
+then move the cursor to the address display, and pick up the
+argument for @code{disassemble} by typing @kbd{C-x &}.
+
+You can customize this further on the fly by defining elements of the list
+@code{gdb-print-command}; once it is defined, you can format or
+otherwise process numbers picked up by @kbd{C-x &} before they are
+inserted. A numeric argument to @kbd{C-x &} will both flag that you
+wish special formatting, and act as an index to pick an element of the
+list. If the list element is a string, the number to be inserted is
+formatted using the Emacs function @code{format}; otherwise the number
+is passed as an argument to the corresponding list element.
+
+@end table
+
+In any source file, the Emacs command @kbd{C-x SPC} (@code{gdb-break})
+tells _GDBN__ to set a breakpoint on the source line point is on.
+
+If you accidentally delete the source-display buffer, an easy way to get
+it back is to type the command @code{f} in the _GDBN__ buffer, to
+request a frame display; when you run under Emacs, this will recreate
+the source buffer if necessary to show you the context of the current
+frame.
+
+The source files displayed in Emacs are in ordinary Emacs buffers
+which are visiting the source files in the usual way. You can edit
+the files with these buffers if you wish; but keep in mind that _GDBN__
+communicates with Emacs in terms of line numbers. If you add or
+delete lines from the text, the line numbers that _GDBN__ knows will cease
+to correspond properly to the code.
+
+@c The following dropped because Epoch is nonstandard. Reactivate
+@c if/when v19 does something similar. ---pesch@cygnus.com 19dec1990
+@ignore
+@kindex emacs epoch environment
+@kindex epoch
+@kindex inspect
+
+Version 18 of Emacs has a built-in window system called the @code{epoch}
+environment. Users of this environment can use a new command,
+@code{inspect} which performs identically to @code{print} except that
+each value is printed in its own window.
+@end ignore
+
+@node _GDBN__ Bugs, Renamed Commands, Emacs, Top
+@chapter Reporting Bugs in _GDBN__
+@cindex Bugs in _GDBN__
+@cindex Reporting Bugs in _GDBN__
+
+Your bug reports play an essential role in making _GDBN__ reliable.
+
+Reporting a bug may help you by bringing a solution to your problem, or it
+may not. But in any case the principal function of a bug report is to help
+the entire community by making the next version of _GDBN__ work better. Bug
+reports are your contribution to the maintenance of _GDBN__.
+
+In order for a bug report to serve its purpose, you must include the
+information that enables us to fix the bug.
+
+@menu
+* Bug Criteria:: Have You Found a Bug?
+* Bug Reporting:: How to Report Bugs
+@end menu
+
+@node Bug Criteria, Bug Reporting, _GDBN__ Bugs, _GDBN__ Bugs
+@section Have You Found a Bug?
+@cindex Bug Criteria
+
+If you are not sure whether you have found a bug, here are some guidelines:
+
+@itemize @bullet
+@item
+@cindex Fatal Signal
+@cindex Core Dump
+If the debugger gets a fatal signal, for any input whatever, that is a
+_GDBN__ bug. Reliable debuggers never crash.
+
+@item
+@cindex error on Valid Input
+If _GDBN__ produces an error message for valid input, that is a bug.
+
+@item
+@cindex Invalid Input
+If _GDBN__ does not produce an error message for invalid input,
+that is a bug. However, you should note that your idea of
+``invalid input'' might be our idea of ``an extension'' or ``support
+for traditional practice''.
+
+@item
+If you are an experienced user of debugging tools, your suggestions
+for improvement of _GDBN__ are welcome in any case.
+@end itemize
+
+@node Bug Reporting, , Bug Criteria, _GDBN__ Bugs
+@section How to Report Bugs
+@cindex Bug Reports
+@cindex Compiler Bugs, Reporting
+
+A number of companies and individuals offer support for GNU products.
+If you obtained _GDBN__ from a support organization, we recommend you
+contact that organization first.
+
+Contact information for many support companies and individuals is
+available in the file @file{etc/SERVICE} in the GNU Emacs distribution.
+
+In any event, we also recommend that you send bug reports for _GDBN__ to one
+of these addresses:
+
+@example
+bug-gdb@@prep.ai.mit.edu
+@{ucbvax|mit-eddie|uunet@}!prep.ai.mit.edu!bug-gdb
+@end example
+
+@strong{Do not send bug reports to @samp{info-gdb}, or to
+@samp{help-gdb}, or to any newsgroups.} Most users of _GDBN__ do not want to
+receive bug reports. Those that do, have arranged to receive @samp{bug-gdb}.
+
+The mailing list @samp{bug-gdb} has a newsgroup which serves as a
+repeater. The mailing list and the newsgroup carry exactly the same
+messages. Often people think of posting bug reports to the newsgroup
+instead of mailing them. This appears to work, but it has one problem
+which can be crucial: a newsgroup posting often lacks a mail path
+back to the sender. Thus, if we need to ask for more information, we
+may be unable to reach you. For this reason, it is better to send bug
+reports to the mailing list.
+
+As a last resort, send bug reports on paper to:
+
+@example
+GNU Debugger Bugs
+545 Tech Square
+Cambridge, MA 02139
+@end example
+
+The fundamental principle of reporting bugs usefully is this:
+@strong{report all the facts}. If you are not sure whether to state a
+fact or leave it out, state it!
+
+Often people omit facts because they think they know what causes the
+problem and assume that some details don't matter. Thus, you might
+assume that the name of the variable you use in an example does not matter.
+Well, probably it doesn't, but one cannot be sure. Perhaps the bug is a
+stray memory reference which happens to fetch from the location where that
+name is stored in memory; perhaps, if the name were different, the contents
+of that location would fool the debugger into doing the right thing despite
+the bug. Play it safe and give a specific, complete example. That is the
+easiest thing for you to do, and the most helpful.
+
+Keep in mind that the purpose of a bug report is to enable us to fix
+the bug if it is new to us. It isn't as important what happens if
+the bug is already known. Therefore, always write your bug reports on
+the assumption that the bug has not been reported previously.
+
+Sometimes people give a few sketchy facts and ask, ``Does this ring a
+bell?'' Those bug reports are useless, and we urge everyone to
+@emph{refuse to respond to them} except to chide the sender to report
+bugs properly.
+
+To enable us to fix the bug, you should include all these things:
+
+@itemize @bullet
+@item
+The version of _GDBN__. _GDBN__ announces it if you start with no
+arguments; you can also print it at any time using @code{show version}.
+
+Without this, we won't know whether there is any point in looking for
+the bug in the current version of _GDBN__.
+
+@item
+A complete input script, and all necessary source files, that will
+reproduce the bug.
+
+@item
+What compiler (and its version) was used to compile _GDBN__---e.g.
+``_GCC__-1.37.1''.
+
+@item
+The command arguments you gave the compiler to compile your example and
+observe the bug. For example, did you use @samp{-O}? To guarantee
+you won't omit something important, list them all.
+
+If we were to try to guess the arguments, we would probably guess wrong
+and then we might not encounter the bug.
+
+@item
+The type of machine you are using, and the operating system name and
+version number.
+
+@item
+A description of what behavior you observe that you believe is
+incorrect. For example, ``It gets a fatal signal.''
+
+Of course, if the bug is that _GDBN__ gets a fatal signal, then we will
+certainly notice it. But if the bug is incorrect output, we might not
+notice unless it is glaringly wrong. We are human, after all. You
+might as well not give us a chance to make a mistake.
+
+Even if the problem you experience is a fatal signal, you should still
+say so explicitly. Suppose something strange is going on, such as,
+your copy of _GDBN__ is out of synch, or you have encountered a
+bug in the C library on your system. (This has happened!) Your copy
+might crash and ours would not. If you told us to expect a crash,
+then when ours fails to crash, we would know that the bug was not
+happening for us. If you had not told us to expect a crash, then we
+would not be able to draw any conclusion from our observations.
+
+@item
+If you wish to suggest changes to the _GDBN__ source, send us context
+diffs. If you even discuss something in the _GDBN__ source, refer to
+it by context, not by line number.
+
+The line numbers in our development sources won't match those in your
+sources. Your line numbers would convey no useful information to us.
+
+@end itemize
+
+Here are some things that are not necessary:
+
+@itemize @bullet
+@item
+A description of the envelope of the bug.
+
+Often people who encounter a bug spend a lot of time investigating
+which changes to the input file will make the bug go away and which
+changes will not affect it.
+
+This is often time consuming and not very useful, because the way we
+will find the bug is by running a single example under the debugger
+with breakpoints, not by pure deduction from a series of examples.
+We recommend that you save your time for something else.
+
+Of course, if you can find a simpler example to report @emph{instead}
+of the original one, that is a convenience for us. Errors in the
+output will be easier to spot, running under the debugger will take
+less time, etc.
+
+However, simplification is not vital; if you don't want to do this,
+report the bug anyway and send us the entire test case you used.
+
+@item
+A patch for the bug.
+
+A patch for the bug does help us if it is a good one. But don't omit
+the necessary information, such as the test case, on the assumption that
+a patch is all we need. We might see problems with your patch and decide
+to fix the problem another way, or we might not understand it at all.
+
+Sometimes with a program as complicated as _GDBN__ it is very hard to
+construct an example that will make the program follow a certain path
+through the code. If you don't send us the example, we won't be able
+to construct one, so we won't be able to verify that the bug is fixed.
+
+And if we can't understand what bug you are trying to fix, or why your
+patch should be an improvement, we won't install it. A test case will
+help us to understand.
+
+@item
+A guess about what the bug is or what it depends on.
+
+Such guesses are usually wrong. Even we can't guess right about such
+things without first using the debugger to find the facts.
+@end itemize
+
+@iftex
+@include rdl-apps.texinfo
+@end iftex
+
+@node Renamed Commands, Installing _GDBN__, _GDBN__ Bugs, Top
+@appendix 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
+OLD COMMAND NEW COMMAND
+--------------- ----------------------------------
+add-syms add-symbol-file
+delete environment unset environment
+info convenience show convenience
+info copying show copying
+info directories show directories
+info editing show commands
+info history show values
+info targets help target
+info values show values
+info version show version
+info warranty show warranty
+set/show addressprint set/show print address
+set/show array-max set/show print elements
+set/show arrayprint set/show print array
+set/show asm-demangle set/show print asm-demangle
+set/show caution set/show confirm
+set/show demangle set/show print demangle
+set/show history write set/show history save
+set/show prettyprint set/show print pretty
+set/show screen-height set/show height
+set/show screen-width set/show width
+set/show sevenbit-strings set/show print sevenbit-strings
+set/show unionprint set/show print union
+set/show vtblprint set/show print vtbl
+
+unset [ No longer an alias for delete ]
+@end ifinfo
+
+@tex
+\vskip \parskip\vskip \baselineskip
+\halign{\tt #\hfil &\qquad#&\tt #\hfil\cr
+{\bf Old Command} &&{\bf New Command}\cr
+add-syms &&add-symbol-file\cr
+delete environment &&unset environment\cr
+info convenience &&show convenience\cr
+info copying &&show copying\cr
+info directories &&show directories \cr
+info editing &&show commands\cr
+info history &&show values\cr
+info targets &&help target\cr
+info values &&show values\cr
+info version &&show version\cr
+info warranty &&show warranty\cr
+set{\rm / }show addressprint &&set{\rm / }show print address\cr
+set{\rm / }show array-max &&set{\rm / }show print elements\cr
+set{\rm / }show arrayprint &&set{\rm / }show print array\cr
+set{\rm / }show asm-demangle &&set{\rm / }show print asm-demangle\cr
+set{\rm / }show caution &&set{\rm / }show confirm\cr
+set{\rm / }show demangle &&set{\rm / }show print demangle\cr
+set{\rm / }show history write &&set{\rm / }show history save\cr
+set{\rm / }show prettyprint &&set{\rm / }show print pretty\cr
+set{\rm / }show screen-height &&set{\rm / }show height\cr
+set{\rm / }show screen-width &&set{\rm / }show width\cr
+set{\rm / }show sevenbit-strings &&set{\rm / }show print sevenbit-strings\cr
+set{\rm / }show unionprint &&set{\rm / }show print union\cr
+set{\rm / }show vtblprint &&set{\rm / }show print vtbl\cr
+\cr
+unset &&\rm(No longer an alias for delete)\cr
+}
+@end tex
+
+@node Installing _GDBN__, Copying, Renamed Commands, Top
+@appendix Installing _GDBN__
+@cindex configuring _GDBN__
+@cindex installation
+
+The script @code{config.gdb} automates the process of preparing _GDBN__
+for installation; you can then use @code{make} to actually build it.
+The best way to build _GDBN__ is in a subdirectory that records the
+configuration options used; this gives you a clean way of building
+_GDBN__ binaries with several different configuration options.
+@code{config.gdb} doesn't depend on this---it's just a good habit. For
+example, assuming the _GDBN__ source is in a directory called
+``@code{gdb-4.0}'':
+
+@example
+cd gdb-4.0
+mkdir =sun3os4
+cd =sun3os4
+../config.gdb sun3os4
+make
+@end example
+
+@noindent
+will install _GDBN__ on a Sun 3 running SunOS 4.
+
+@table @code
+@kindex config.gdb
+@item config.gdb @var{machine}
+@itemx config.gdb -srcdir=@var{dir} @var{machine}
+This is the most usual way of configuring _GDBN__; to debug programs running
+on the same machine as _GDBN__ itself. If you wish to build the _GDBN__ binaries
+in a completely different directory from the sources, specify a path to
+the source directory using the @samp{-srcdir} option.
+
+@item config.gdb -host
+@cindex host environments
+Display a list of supported host environments for _GDBN__.
+
+@item config.gdb @var{host} @var{target}
+@itemx config.gdb -srcdir=@var{dir} @var{host} @var{target}
+@cindex cross-debugging
+_GDBN__ can also be used as a cross-debugger, running on a machine of one
+type while debugging a program running on a machine of another type.
+You configure it this way by specifying first the @var{host}, then the
+@var{target} environment on the @code{config.gdb} argument list; the
+@var{host} is where _GDBN__ runs, and the @var{target} is where your program
+runs. @xref{Remote}. Again, you can use @samp{-srcdir} to specify a
+path to the _GDBN__ source.
+
+@item config.gdb -target
+@cindex target environments
+Display a list of supported target environments for _GDBN__.
+@end table
+
+@node Copying, Index, Installing _GDBN__, Top
+@appendix Copying GDB
+@c this is an attempt to kluge around what may be a bug in texinfo;
+@c @xrefs to this node came out pointing several pages further down when
+@c the @node was immediately followed by @unnumbered.
+@c While we're at it, might as well give an Appendix heading that
+@c matches RMS' preferred nodename "Copying".
+
+@unnumbered GNU GENERAL PUBLIC LICENSE
+@center Version 1, February 1989
+
+@display
+Copyright @copyright{} 1989 Free Software Foundation, Inc.
+675 Mass Ave, Cambridge, MA 02139, USA
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+@end display
+
+@unnumberedsec Preamble
+
+ The license agreements of most software companies try to keep users
+at the mercy of those companies. By contrast, our General Public
+License is intended to guarantee your freedom to share and change free
+software---to make sure the software is free for all its users. The
+General Public License applies to the Free Software Foundation's
+software and to any other program whose authors commit to using it.
+You can use it for your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Specifically, the General Public License is designed to make
+sure that you have the freedom to give away or sell copies of free
+software, that you receive source code or can get it if you want it,
+that you can change the software or use pieces of it in new free
+programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of a such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must tell them their rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+@iftex
+@unnumberedsec TERMS AND CONDITIONS
+@end iftex
+@ifinfo
+@center TERMS AND CONDITIONS
+@end ifinfo
+
+@enumerate
+@item
+This License Agreement applies to any program or other work which
+contains a notice placed by the copyright holder saying it may be
+distributed under the terms of this General Public License. The
+``Program'', below, refers to any such program or work, and a ``work based
+on the Program'' means either the Program or any work containing the
+Program or a portion of it, either verbatim or with modifications. Each
+licensee is addressed as ``you''.
+
+@item
+You may copy and distribute verbatim copies of the Program's source
+code as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and
+disclaimer of warranty; keep intact all the notices that refer to this
+General Public License and to the absence of any warranty; and give any
+other recipients of the Program a copy of this General Public License
+along with the Program. You may charge a fee for the physical act of
+transferring a copy.
+
+@item
+You may modify your copy or copies of the Program or any portion of
+it, and copy and distribute such modifications under the terms of Paragraph
+1 above, provided that you also do the following:
+
+@itemize @bullet
+@item
+cause the modified files to carry prominent notices stating that
+you changed the files and the date of any change; and
+
+@item
+cause the whole of any work that you distribute or publish, that
+in whole or in part contains the Program or any part thereof, either
+with or without modifications, to be licensed at no charge to all
+third parties under the terms of this General Public License (except
+that you may choose to grant warranty protection to some or all
+third parties, at your option).
+
+@item
+If the modified program normally reads commands interactively when
+run, you must cause it, when started running for such interactive use
+in the simplest and most usual way, to print or display an
+announcement including an appropriate copyright notice and a notice
+that there is no warranty (or else, saying that you provide a
+warranty) and that users may redistribute the program under these
+conditions, and telling the user how to view a copy of this General
+Public License.
+
+@item
+You may charge a fee for the physical act of transferring a
+copy, and you may at your option offer warranty protection in
+exchange for a fee.
+@end itemize
+
+Mere aggregation of another independent work with the Program (or its
+derivative) on a volume of a storage or distribution medium does not bring
+the other work under the scope of these terms.
+
+@item
+You may copy and distribute the Program (or a portion or derivative of
+it, under Paragraph 2) in object code or executable form under the terms of
+Paragraphs 1 and 2 above provided that you also do one of the following:
+
+@itemize @bullet
+@item
+accompany it with the complete corresponding machine-readable
+source code, which must be distributed under the terms of
+Paragraphs 1 and 2 above; or,
+
+@item
+accompany it with a written offer, valid for at least three
+years, to give any third party free (except for a nominal charge
+for the cost of distribution) a complete machine-readable copy of the
+corresponding source code, to be distributed under the terms of
+Paragraphs 1 and 2 above; or,
+
+@item
+accompany it with the information you received as to where the
+corresponding source code may be obtained. (This alternative is
+allowed only for noncommercial distribution and only if you
+received the program in object code or executable form alone.)
+@end itemize
+
+Source code for a work means the preferred form of the work for making
+modifications to it. For an executable file, complete source code means
+all the source code for all modules it contains; but, as a special
+exception, it need not include source code for modules which are standard
+libraries that accompany the operating system on which the executable
+file runs, or for standard header files or definitions files that
+accompany that operating system.
+
+@item
+You may not copy, modify, sublicense, distribute or transfer the
+Program except as expressly provided under this General Public License.
+Any attempt otherwise to copy, modify, sublicense, distribute or transfer
+the Program is void, and will automatically terminate your rights to use
+the Program under this License. However, parties who have received
+copies, or rights to use copies, from you under this General Public
+License will not have their licenses terminated so long as such parties
+remain in full compliance.
+
+@item
+By copying, distributing or modifying the Program (or any work based
+on the Program) you indicate your acceptance of this license to do so,
+and all its terms and conditions.
+
+@item
+Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the original
+licensor to copy, distribute or modify the Program subject to these
+terms and conditions. You may not impose any further restrictions on the
+recipients' exercise of the rights granted herein.
+
+@item
+The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of the license which applies to it and ``any
+later version'', you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+the license, you may choose any version ever published by the Free Software
+Foundation.
+
+@item
+If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+@iftex
+@heading NO WARRANTY
+@end iftex
+@ifinfo
+@center NO WARRANTY
+@end ifinfo
+
+@item
+BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+@item
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
+ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
+LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
+SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
+WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+@end enumerate
+
+@iftex
+@heading END OF TERMS AND CONDITIONS
+@end iftex
+@ifinfo
+@center END OF TERMS AND CONDITIONS
+@end ifinfo
+
+@page
+@unnumberedsec Applying These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to humanity, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+ To do so, attach the following notices to the program. It is safest to
+attach them to the start of each source file to most effectively convey
+the exclusion of warranty; and each file should have at least the
+``copyright'' line and a pointer to where the full notice is found.
+
+@smallexample
+@var{one line to give the program's name and a brief idea of what it does.}
+Copyright (C) 19@var{yy} @var{name of author}
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 1, or (at your option)
+any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+@end smallexample
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+@smallexample
+Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
+Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+This is free software, and you are welcome to redistribute it
+under certain conditions; type `show c' for details.
+@end smallexample
+
+The hypothetical commands `show w' and `show c' should show the
+appropriate parts of the General Public License. Of course, the
+commands you use may be called something other than `show w' and `show
+c'; they could even be mouse-clicks or menu items---whatever suits your
+program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a ``copyright disclaimer'' for the program, if
+necessary. Here is a sample; alter the names:
+
+@smallexample
+Yoyodyne, Inc., hereby disclaims all copyright interest in the
+program `Gnomovision' (a program to direct compilers to make passes
+at assemblers) written by James Hacker.
+
+@var{signature of Ty Coon}, 1 April 1989
+Ty Coon, President of Vice
+@end smallexample
+
+That's all there is to it!
@node Index, , Copying, Top
@unnumbered Index
projects / binutils-gdb.git / commitdiff