5504 lines
202 KiB
Plaintext
5504 lines
202 KiB
Plaintext
\input texinfo
|
|
@setfilename _GDBP__.info
|
|
@c
|
|
@c NOTE: this manual is marked up for preprocessing with a collection
|
|
@c of m4 macros called "pretex.m4". If you see <_if__> and <_fi__>
|
|
@c scattered around the source, you have the full source before
|
|
@c preprocessing; if you don't, you have the source configured for
|
|
@c _HOST__ architectures (and you can of course get the full source,
|
|
@c with all configurations, from wherever you got this).
|
|
_if__(0)
|
|
|
|
THIS IS THE FULL SOURCE. The full source needs to be run through m4
|
|
before either tex- or info- formatting: for example,
|
|
_0__
|
|
m4 pretex.m4 none.m4 m680x0.m4 gdb.texinfo >gdb-680x0.texinfo
|
|
_1__
|
|
will produce (assuming your path finds either GNU or SysV m4; Berkeley
|
|
won't do) a file suitable for formatting. See the text in "pretex.m4"
|
|
for a fuller explanation (and the macro definitions).
|
|
To permit maximum flexibility, the full source also does not contain
|
|
any "info" markup that can be generated automatically; you should first
|
|
preprocess it as above, then run it through C-u texinfo-master-menu,
|
|
before actually info-formatting it.
|
|
_fi__(0)
|
|
@c
|
|
@syncodeindex ky cp
|
|
@c FOR UPDATES LEADING TO THIS DRAFT, GDB CHANGELOG CONSULTED BETWEEN:
|
|
@c Tue Feb 26 01:47:07 1991 Cygnus John Gilmore (cygnus at yuba)
|
|
@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 author instead of in the
|
|
original English.
|
|
@end ifinfo
|
|
@smallbook
|
|
@setchapternewpage odd
|
|
_if__(_GENERIC__)
|
|
@settitle Using _GDBN__ (v4.0)
|
|
_fi__(_GENERIC__)
|
|
_if__(!_GENERIC__)
|
|
@settitle Using _GDBN__ v4.0 (_HOST__)
|
|
_fi__(!_GENERIC__)
|
|
@iftex
|
|
@c @finalout
|
|
@end iftex
|
|
@titlepage
|
|
@title{Using _GDBN__}
|
|
@subtitle{A Guide to the GNU Source-Level Debugger}
|
|
_if__(!_GENERIC__)
|
|
@subtitle{On _HOST__ Systems}
|
|
_fi__(!_GENERIC__)
|
|
@sp 1
|
|
@c Maybe crank this up to "Fourth Edition" when released at FSF
|
|
@c @subtitle Third Edition---_GDBN__ version 4.0
|
|
@subtitle _GDBN__ version 4.0
|
|
@subtitle April 1991
|
|
@author{Richard M. Stallman}
|
|
@author{Roland H. Pesch --- Cygnus Support}
|
|
@page
|
|
|
|
@tex
|
|
\def\$#1${{#1}} % Kluge: collect RCS revision info without $...$
|
|
\xdef\manvers{\$Revision$} % For use in headers, footers too
|
|
{\parskip=0pt
|
|
\hfill Cygnus Support\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 author instead of in the
|
|
original English.
|
|
@end titlepage
|
|
@page
|
|
|
|
@node 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:
|
|
|
|
@enumerate
|
|
@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 enumerate
|
|
|
|
_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.
|
|
|
|
@unnumberedsec Free Software
|
|
_GDBN__ is 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.
|
|
|
|
For full details, @pxref{License}.
|
|
|
|
@node New Features,,,
|
|
@unnumbered New Features in _GDBN__ version 4.0
|
|
|
|
@itemize @bullet
|
|
@item
|
|
TARGETS: Using the new command @samp{target}, you can select at runtime
|
|
whether you are debugging local files, local processes, standalone
|
|
systems over the serial port, realtime systems over a TCP/IP
|
|
connection, etc. _GDBN__ now uses a function vector to mediate access to
|
|
all the different possible targets, making it much easier to add
|
|
support for new remote protocols.
|
|
|
|
@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 the inferior
|
|
process 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 new
|
|
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: You must still choose a particular machine architecture
|
|
and operating system for _GDBN__'s host and target systems when _GDBN__ is built.
|
|
The script @samp{config.gdb} now handles specification of separate host
|
|
and target configurations.
|
|
|
|
@item
|
|
INTERACTION: _GDBN__ now uses the GNU readline interface to read its
|
|
input; this provides inline editing of commands, using the familiar
|
|
Emacs or @code{vi} keymaps, and command-history support. The user interface
|
|
to _GDBN__'s control variables has been simplified and consolidated in two
|
|
commands, @samp{set} and @samp{show}. Output lines are now broken at
|
|
readable places, rather than overflowing onto the next line.
|
|
|
|
@item
|
|
SOURCE LANGUAGE: _GDBN__ now understands C++ source as well as C. Multiple
|
|
inheritance is supported when used with G++ 2.0. There is also 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. You can suppress output of machine-level addresses,
|
|
displaying only source language information.
|
|
|
|
@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 itemize
|
|
|
|
@node Sample Session,,,
|
|
@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.
|
|
|
|
In this sample session, we emphasize user input like this: @var{input},
|
|
to make it easier to pick out from the surrounding output.
|
|
|
|
@c FIXME: this example may not be appropriate for some configs, where
|
|
@c FIXME...primary interest is in remote use.
|
|
We'll be using _GDBN__ to inspect GNU @code{m4} (a generic macro
|
|
processor).
|
|
|
|
_0__@smallexample
|
|
$ @var{cd gm4/common}
|
|
|
|
$ @var{_GDBP__ m4}
|
|
Reading symbol data from m4...done.
|
|
(_GDBP__) set width 70
|
|
@end smallexample
|
|
|
|
@noindent
|
|
_GDBN__ only reads enough symbol data to know where to find the rest
|
|
when needed; as a result, the first prompt comes up very quickly. We
|
|
immediately told _GDBN__ to use a narrower display width than usual, so
|
|
that examples will fit in this manual.
|
|
|
|
@smallexample
|
|
(_GDBP__) @var{break m4_changequote}
|
|
Breakpoint 1 at 0x59d4: file builtin.c, line 812.
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We've chosen to see how the @code{m4} builtin @samp{changequote} works.
|
|
Having looked at the source, we knew the relevant subroutine is
|
|
@samp{m4_changequote}. We've set a breakpoint there with _GDBN__'s
|
|
@code{break} command.
|
|
|
|
@smallexample
|
|
(_GDBP__) @var{run}
|
|
Starting program: /s1/gnu/src/gm4/common/m4
|
|
@var{`usual' quotes <not these>}
|
|
usual quotes <not these>
|
|
@end smallexample
|
|
|
|
@noindent
|
|
Using the @samp{run} command, we've started @code{m4} running under
|
|
_GDBN__ control; while we don't touch the @samp{m4_changequote}
|
|
subroutine, the program runs as usual---it filters standard input.
|
|
|
|
@smallexample
|
|
@var{changequote(<,>)}
|
|
|
|
Breakpoint 1, m4_changequote (argc=3, argv=0x2b958) at builtin.c:812
|
|
812 if (bad_argc(TOKEN_DATA_TEXT(argv[0]), argc, 1, 3))
|
|
@end smallexample
|
|
@noindent
|
|
To trigger the breakpoint, we called @code{changequote}. _GDBN__
|
|
suspended execution of @code{m4}, displaying information about the
|
|
context where it stopped.
|
|
|
|
@group
|
|
@smallexample
|
|
(_GDBP__) @var{s}
|
|
bad_argc (name=0xf851cfb4<Address 0xf851cfb4 out of bounds>, argc=3,
|
|
min=1, max=3) at builtin.c:230
|
|
230 if (min > 0 && argc < min) @{
|
|
@end smallexample
|
|
@noindent
|
|
We've used the command @samp{s} (@code{step}) to advance execution to
|
|
the next source line; since there was a subroutine call, we've stopped
|
|
in the first line of that subroutine, not in the next line of
|
|
@code{m4_changequote}.
|
|
@end group
|
|
|
|
The command @samp{next} would have taken us to the next line of
|
|
@code{m4_changequote}. To see where we are in the stack, we can use the
|
|
@samp{backtrace} command (which can also be spelled @samp{bt}).
|
|
|
|
@smallexample
|
|
(_GDBP__) @var{bt}
|
|
#0 bad_argc (name=0xf851cfb4<Address 0xf851cfb4 out of bounds>,
|
|
argc=3, min=1, max=3) at builtin.c:230
|
|
#1 0x59ec in m4_changequote (argc=3, argv=0x2b958) at builtin.c:812
|
|
#2 0x6e38 in expand_macro (sym=0x2b060) at macro.c:242
|
|
#3 0x6840 in expand_token (obs=0x0, t=176224, td=0xf7fffb08)
|
|
at macro.c:71
|
|
#4 0x6794 in expand_input () at macro.c:40
|
|
#5 0x28dc in main (argc=0, argv=0xf7fffbf8) at m4.c:174
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We'll tell _GDBN__ to finish execution of this subroutine, to get back
|
|
to @code{m4_changequote}.
|
|
|
|
@smallexample
|
|
(_GDBP__) @var{finish}
|
|
Run till exit from #0 bad_argc (name=0xf851cfb4<Address 0xf851cfb4 out
|
|
of bounds>,
|
|
argc=3, min=1, max=3) at builtin.c:230
|
|
0x59ec in m4_changequote (argc=3, argv=0x2b958) at builtin.c:812
|
|
812 if (bad_argc(TOKEN_DATA_TEXT(argv[0]), argc, 1, 3))
|
|
Value returned is $1 = false
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We're still in the middle of the first line of @code{m4_changequote};
|
|
@samp{finish} just allowed the subroutine call to complete.
|
|
The display beginning ``@code{0x59ec in}@dots{}'', preceding the
|
|
display of line @code{812}, is a reminder of that situation from
|
|
_GDBN__.
|
|
|
|
Now that we're past the subroutine call, using the @code{step} command
|
|
again will get us to the next line of @code{m4_changequote}.
|
|
|
|
@smallexample
|
|
(_GDBP__) @var{s}
|
|
815 lquote = (argc >= 2) ? TOKEN_DATA_TEXT(argv[1])[0] : DEF_LQUOTE;
|
|
(_GDBP__) @var{whatis lquote}
|
|
type = char
|
|
(_GDBP__) @var{p lquote}
|
|
$2 = 96 '`'
|
|
@end smallexample
|
|
|
|
@noindent
|
|
When we stepped to another line, @code{m4} was about to set a variable
|
|
@samp{lquote}; we inspected its type with @samp{whatis} and its value
|
|
with @samp{p} (the @samp{print} command). We can see some context by
|
|
displaying the surrounding source code, with the @samp{l} (@code{list})
|
|
command.
|
|
|
|
@smallexample
|
|
(_GDBP__) @var{l}
|
|
810 token_data **argv;
|
|
811 @{
|
|
812 if (bad_argc(TOKEN_DATA_TEXT(argv[0]), argc, 1, 3))
|
|
813 return;
|
|
814
|
|
815 lquote = (argc >= 2) ? TOKEN_DATA_TEXT(argv[1])[0] : DEF_LQUOTE;
|
|
816 rquote = (argc >= 3) ? TOKEN_DATA_TEXT(argv[2])[0] : DEF_RQUOTE;
|
|
817 @}
|
|
818
|
|
819 /*
|
|
(_GDBP__) @var{s}
|
|
816 rquote = (argc >= 3) ? TOKEN_DATA_TEXT(argv[2])[0] : DEF_RQUOTE;
|
|
(_GDBP__) @var{s}
|
|
817 @}
|
|
(_GDBP__) @var{p lquote}
|
|
$3 = 60 '<'
|
|
(_GDBP__) @var{p rquote}
|
|
$4 = 62 '>'
|
|
@end smallexample
|
|
|
|
@noindent
|
|
We proceeded past another line with @samp{s}, and inspected the new
|
|
values of @code{m4}'s internal variables @code{rquote} and
|
|
@code{lquote}.
|
|
|
|
Since we're done with our inspection of this subroutine, we'll tell
|
|
_GDBN__ to allow @code{m4} to continue running, with the @samp{c}
|
|
(@code{continue}) command:
|
|
|
|
@smallexample
|
|
(_GDBP__) @var{c}
|
|
Continuing.
|
|
|
|
@var{`usual' quotes <not these>}
|
|
`usual' quotes not these
|
|
|
|
Program exited normally.
|
|
(_GDBP__) @var{quit}
|
|
|
|
$
|
|
_1__@end smallexample
|
|
|
|
@noindent
|
|
Finally, when we ended the @code{m4} run, _GDBN__ told us
|
|
``@code{Program exited normally.}'' We ended our _GDBN__ session with
|
|
the _GDBN__ @samp{quit} command.
|
|
|
|
|
|
@node Invocation,,,
|
|
@chapter Getting In and Out of _GDBN__
|
|
|
|
@node Starting _GDBN__,,,
|
|
@section Starting _GDBN__
|
|
|
|
_GDBN__ is invoked with the shell command @samp{_GDBP__}. Once started,
|
|
it reads commands from the terminal until you tell it to exit.
|
|
|
|
You can start by just calling @samp{_GDBP__} with no arguments or
|
|
options; but the most usual way to start _GDBN__ is with one argument or
|
|
two, specifying an executable program as the argument:
|
|
@example
|
|
_GDBP__ program
|
|
@end example
|
|
@noindent
|
|
You can also start with both an executable program and a core file specified:
|
|
@example
|
|
_GDBP__ program core
|
|
@end example
|
|
|
|
You can further control how _GDBN__ starts up by using command-line
|
|
options.
|
|
|
|
_GDBN__ itself can remind you of the options available:
|
|
@example
|
|
gdb -help
|
|
@end example
|
|
@noindent
|
|
will display all available options and briefly describe their use
|
|
(@samp{gdb -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.
|
|
|
|
@node File Options,,,
|
|
@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.
|
|
|
|
@table @code
|
|
@item -symbols @var{file}
|
|
@itemx -s @var{file}
|
|
Read symbol table from file @var{file}.
|
|
|
|
@item -exec @var{file}
|
|
@itemx -e @var{file}
|
|
Use file @var{file} as the executable file to execute when
|
|
appropriate, and for examining pure data in conjunction with a core
|
|
dump.
|
|
|
|
@item -se @var{file}
|
|
Read symbol table from file @var{file} and use it as the executable
|
|
file.
|
|
|
|
@item -core @var{file}
|
|
@itemx -c @var{file}
|
|
Use file @var{file} as a core dump to examine.
|
|
|
|
@item -command @var{file}
|
|
@itemx -x @var{file}
|
|
Execute _GDBN__ commands from file @var{file}. @xref{Command Files}.
|
|
|
|
@item -directory @var{directory}
|
|
@itemx -d @var{directory}
|
|
Add @var{directory} to the path to search for source files.
|
|
@end table
|
|
|
|
@node Mode Options,,,
|
|
@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 code @code{0} after processing all the command
|
|
files specified with @samp{-x} (and @file{_GDBINIT__}, if not inhibited).
|
|
Exit with nonzero status if an error occurs in executing the _GDBN__
|
|
commands in the command files.
|
|
|
|
Batch mode may be useful for running _GDBN__ as a filter, for example to
|
|
download and run a program on another computer; in order to make this
|
|
more useful, the message
|
|
@example
|
|
Program exited normally.
|
|
@end example
|
|
@noindent
|
|
(which is ordinarily issued whenever a program running under _GDBN__ control
|
|
terminates) is not issued when running in batch mode.
|
|
|
|
@item -cd @var{directory}
|
|
Run _GDBN__ using @var{directory} as its working directory,
|
|
instead of the current directory.
|
|
|
|
@item -fullname
|
|
@itemx -f
|
|
This option is used when Emacs runs _GDBN__ as a subprocess. It tells _GDBN__
|
|
to output the full file name and line number in a standard,
|
|
recognizable fashion each time a stack frame is displayed (which
|
|
includes each time the program stops). This recognizable format looks
|
|
like two @samp{\032} characters, followed by the file name, line number
|
|
and character position separated by colons, and a newline. The
|
|
Emacs-to-_GDBN__ interface program uses the two @samp{\032} characters as
|
|
a signal to display the source code for the frame.
|
|
|
|
@item -b @var{bps}
|
|
Set the line speed (baud rate or bps) of any serial interface used by
|
|
_GDBN__ for remote debugging.
|
|
|
|
@item -tty @var{device}
|
|
Run using @code{device} for your program's standard input and output.
|
|
@end table
|
|
|
|
_if__(_I960__)
|
|
@node i960-Nindy Remote,,,
|
|
@subsection _GDBN__ with a Remote i960 (Nindy)
|
|
|
|
``Nindy'' is the name of a ROM Monitor program for Intel 960 target
|
|
systems. When _GDBN__ is configured to control a remote Intel 960 using
|
|
Nindy, you can tell _GDBN__ how to connect to the 960 in several ways:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Through command line options specifying device, baud rate, and protocol;
|
|
|
|
@item
|
|
By responding to a prompt on startup;
|
|
|
|
@item
|
|
By using the @samp{target} command at any point during your _GDBN__ session.
|
|
@end itemize
|
|
|
|
@node Nindy Startup,,,
|
|
@subsubsection Startup with Nindy
|
|
|
|
The command-line options for Nindy are detailed below. If you simply
|
|
start @code{_GDBP__} without using options to specify a serial port, you are
|
|
prompted for it, @emph{before} you reach the ordinary _GDBN__ prompt:
|
|
@example
|
|
Attach /dev/ttyNN -- specify NN, or "quit" to quit:
|
|
@end example
|
|
@noindent
|
|
You can, if you choose, simply start up with no Nindy connection by
|
|
responding to the prompt with an empty line. If you do this, and later
|
|
wish to attach to Nindy, use @samp{target} (@pxref{Target Commands}).
|
|
|
|
@node Nindy Options,,,
|
|
@subsubsection Options for Nindy
|
|
|
|
These are the startup options for beginning your _GDBN__ session with a
|
|
Nindy-960 board attached:
|
|
|
|
@table @code
|
|
@item -r @var{port}
|
|
Specify the serial port name of a serial interface to be used to connect
|
|
to the target system. This option is only available when _GDBN__ is
|
|
configured for the Intel 960 target architecture. You may specify
|
|
@var{port} as any of: a full pathname (e.g. @samp{-r /dev/ttya}), a
|
|
device name in @samp{/dev} (e.g. @samp{-r ttya}), or simply the unique
|
|
suffix for a specific @code{tty} (e.g. @samp{-r a}).
|
|
|
|
@item -O
|
|
(An uppercase letter ``O'', not a zero.) Specify that _GDBN__ should use
|
|
the ``old'' Nindy monitor protocol to connect to the target system.
|
|
This option is only available when _GDBN__ is configured for the Intel 960
|
|
target architecture.
|
|
|
|
@quotation
|
|
@emph{Warning:} if you specify @samp{-O}, but are actually trying to
|
|
connect to a target system that expects the newer protocol, the connection
|
|
will fail, appearing to be a speed mismatch. _GDBN__ will repeatedly
|
|
attempt to reconnect at several different line speeds. You can abort
|
|
this process with an interrupt.
|
|
@end quotation
|
|
|
|
@item -brk
|
|
Specify that _GDBN__ should first send a @samp{BREAK} signal to the target
|
|
system, in an attempt to reset it, before connecting to a Nindy target.
|
|
|
|
@quotation
|
|
@emph{Warning:} Many target systems do not have the hardware that this
|
|
requires; it only works with a few boards.
|
|
@end quotation
|
|
|
|
@end table
|
|
|
|
The standard @samp{-b} option controls the line speed used on the serial
|
|
port.
|
|
|
|
@group
|
|
@node Nindy reset,,,
|
|
@subsubsection Nindy Reset Command
|
|
@table @code
|
|
@item reset
|
|
@kindex reset
|
|
For a Nindy target, this command sends a ``break'' to the remote target
|
|
system; this is only useful if the target has been equipped with a
|
|
circuit to perform a hard reset (or some other interesting action) when
|
|
a break is detected.
|
|
@end table
|
|
@end group
|
|
_fi__(_I960__)
|
|
|
|
_if__(_AMD29K__)
|
|
@node EB29K Remote,,,
|
|
@subsection _GDBN__ with a Remote EB29K
|
|
|
|
@cindex EB29K board
|
|
@cindex running 29K programs
|
|
@cindex 29K
|
|
|
|
To use _GDBN__ from a Unix system to run programs on AMD's EB29K
|
|
board in a PC, you must first connect a serial cable between the PC
|
|
and a serial port on the Unix system. In the following, we assume
|
|
you've hooked the cable between the PC's @samp{COM1} port and
|
|
@samp{/dev/ttya} on the Unix system.
|
|
|
|
@node Comms (EB29K),,,
|
|
@subsubsection Communications Setup
|
|
The next step is to set up the PC's port, by doing something like the
|
|
following in DOS on the PC:
|
|
_0__@example
|
|
C:\> MODE com1:9600,n,8,1,none
|
|
_1__@end example
|
|
@noindent
|
|
This example---run on an MS DOS 4.0 system---sets the PC port to 9600
|
|
bps, no parity, eight data bits, one stop bit, and no ``retry'' action;
|
|
you must match the communications parameters when establishing the Unix
|
|
end of the connection as well.
|
|
@c FIXME: Who knows what this "no retry action" crud from the DOS manual may
|
|
@c mean? It's optional; leave it out? ---pesch@cygnus.com, 25feb91
|
|
|
|
To give control of the PC to the Unix side of the serial line, type
|
|
the following at the DOS console:
|
|
_0__@example
|
|
C:\> CTTY com1
|
|
_1__@end example
|
|
@noindent
|
|
(Later, if you wish to return control to the DOS console, you can use
|
|
the command @samp{CTTY con}---but you must send it over the device that
|
|
had control, in our example over the @samp{COM1} serial line).
|
|
|
|
From the Unix host, use a communications program such as @code{tip} or
|
|
@code{cu} to communicate with the PC; for example,
|
|
@example
|
|
cu -s 9600 -l /dev/ttya
|
|
@end example
|
|
@noindent
|
|
The @code{cu} options shown specify, respectively, the linespeed and the
|
|
serial port to use. If you use @code{tip} instead, your command line
|
|
may look something like the following instead:
|
|
@example
|
|
tip -9600 /dev/ttya
|
|
@end example
|
|
@noindent
|
|
Your system may define a different name where our example uses
|
|
@samp{/dev/ttya} as the argument to @code{tip}. The communications
|
|
parameters, including what port to use, are associated with the
|
|
@code{tip} argument in the ``remote'' descriptions file---normally the
|
|
system table @file{/etc/remote}.
|
|
@c FIXME: What if anything needs doing to match the "n,8,1,none" part of
|
|
@c the DOS side's comms setup? cu can support -o (odd
|
|
@c parity), -e (even parity)---apparently no settings for no parity or
|
|
@c for character size. Taken from stty maybe...? John points out tip
|
|
@c can set these as internal variables, eg ~s parity=none; man stty
|
|
@c suggests that it *might* work to stty these options with stdin or
|
|
@c stdout redirected... ---pesch@cygnus.com, 25feb91
|
|
|
|
@kindex EBMON
|
|
Using the @samp{tip} or @samp{cu} connection, change the DOS working
|
|
directory to the directory containing a copy of your 29K program, then
|
|
start the PC program @samp{EBMON} (an EB29K control program supplied
|
|
with your board by AMD). You should see an initial display from
|
|
@code{EBMON} similar to the one that follows, ending with the
|
|
@code{EBMON} prompt @samp{#}---
|
|
_0__@example
|
|
C:\> G:
|
|
|
|
G:\> CD \usr\joe\work29k
|
|
|
|
G:\USR\JOE\WORK29K> EBMON
|
|
Am29000 PC Coprocessor Board Monitor, version 3.0-18
|
|
Copyright 1990 Advanced Micro Devices, Inc.
|
|
Written by Gibbons and Associates, Inc.
|
|
|
|
Enter '?' or 'H' for help
|
|
|
|
PC Coprocessor Type = EB29K
|
|
I/O Base = 0x208
|
|
Memory Base = 0xd0000
|
|
|
|
Data Memory Size = 2048KB
|
|
Available I-RAM Range = 0x8000 to 0x1fffff
|
|
Available D-RAM Range = 0x80002000 to 0x801fffff
|
|
|
|
PageSize = 0x400
|
|
Register Stack Size = 0x800
|
|
Memory Stack Size = 0x1800
|
|
|
|
CPU PRL = 0x3
|
|
Am29027 Available = No
|
|
Byte Write Available = Yes
|
|
|
|
# ~.
|
|
_1__@end example
|
|
|
|
Then exit the @code{cu} or @code{tip} program (done in the example by
|
|
typing @code{~.} at the @code{EBMON} prompt). @code{EBMON} will keep
|
|
running, ready for _GDBN__ to take over.
|
|
|
|
For this example, we've assumed what is probably the most convenient
|
|
way to make sure the same 29K program is on both the PC and the Unix
|
|
system: a PC/NFS connection that establishes ``drive @code{G:}'' on the
|
|
PC as a file system on the Unix host. If you don't have PC/NFS or
|
|
something similar connecting the two systems, you must arrange some
|
|
other way---perhaps floppy-disk transfer---of getting the 29K program
|
|
from the Unix system to the PC; _GDBN__ will @emph{not} download it over the
|
|
serial line.
|
|
|
|
@node _GDBP__-EB29K,,,
|
|
@subsubsection EB29K cross-debugging
|
|
Finally, @code{cd} to the directory containing an image of your 29K
|
|
program on the Unix system, and start _GDBN__---specifying as argument the
|
|
name of your 29K program:
|
|
@example
|
|
cd /usr/joe/work29k
|
|
_GDBP__ myfoo
|
|
@end example
|
|
Now you can use the @code{target} command:
|
|
@example
|
|
target amd-eb /dev/ttya 9600 MYFOO
|
|
@end example
|
|
@c FIXME: test above 'target amd-eb' as spelled, with caps! caps are meant to
|
|
@c emphasize that this is the name as seen by DOS (since I think DOS is
|
|
@c single-minded about case of letters). ---pesch@cygnus.com, 25feb91
|
|
|
|
@noindent
|
|
In this example, we've assumed your program is in a file called
|
|
@samp{myfoo}. Note that the filename given as the last argument to
|
|
@samp{target amd-eb} should be the name of the program as it appears to DOS.
|
|
In our example this is simply @samp{MYFOO}, but in general it can include
|
|
a DOS path, and depending on your transfer mechanism may not resemble
|
|
the name on the Unix side.
|
|
|
|
At this point, you can set any breakpoints you wish; when you're ready
|
|
to see your program run on the 29K board, use the _GDBN__ command
|
|
@example
|
|
run
|
|
@end example
|
|
|
|
To stop debugging the remote program, use the _GDBN__ @samp{detach}
|
|
command.
|
|
|
|
To return control of the PC to its console, use @code{tip} or @code{cu}
|
|
once again, after your _GDBN__ session has concluded, to attach to
|
|
@code{EBMON}. You can then type the command @samp{q} to shut down
|
|
@code{EBMON}, returning control to the DOS command-line interpreter.
|
|
Type @samp{CTTY con} to return command input to the main DOS console,
|
|
and type @samp{~.} to leave @code{tip} or @code{cu}.
|
|
|
|
@node Remote Log,,,
|
|
@subsubsection Remote Log
|
|
@kindex eb.log
|
|
@cindex log file for EB29K
|
|
The @samp{target amd-eb} command creates a file @file{eb.log} in the
|
|
current working directory, to help debug problems with the connection.
|
|
@file{eb.log} records all the output from @code{EBMON}, including echoes
|
|
of the commands sent to it. Running @samp{tail -f} on this file in
|
|
another window often helps to understand trouble with @code{EBMON}, or
|
|
unexpected events on the PC side of the connection.
|
|
_fi__(_AMD29K__)
|
|
|
|
_if__(_VXWORKS__)
|
|
@node VxWorks Remote,,,
|
|
@subsection _GDBN__ and VxWorks
|
|
_GDBN__ enables developers to spawn and debug tasks running on networked
|
|
VxWorks targets from a Unix host. Already-running tasks spawned from
|
|
the VxWorks shell can also be debugged. _GDBN__ uses code that runs on
|
|
both the UNIX host and on the VxWorks target. The program
|
|
@code{_GDBP__} is installed and executed on the UNIX host.
|
|
|
|
The remote debugging interface (RDB) routines are installed and executed
|
|
on the VxWorks target. These routines are included in the VxWorks library
|
|
@code{rdb.a} and are incorporated into the system image when source-level
|
|
debugging is enabled in the VxWorks configuration.
|
|
|
|
Defining @code{INCLUDE_RDB} in the VxWorks configuration file
|
|
@code{configAll.h} includes the RDB interface routines and spawns the
|
|
source debugging task @code{tRdbTask} when VxWorks is booted. For more
|
|
information on configuring and remaking VxWorks, see the @cite{VxWorks
|
|
Programmer's Guide}.
|
|
|
|
Once you have included the RDB interface in your VxWorks system image
|
|
and set your Unix execution search path to find _GDBN__, you are ready
|
|
to run _GDBN__. From your UNIX host, type:
|
|
|
|
@smallexample
|
|
% _GDBP__
|
|
@end smallexample
|
|
|
|
_GDBN__ will come up showing the prompt:
|
|
|
|
@smallexample
|
|
(_GDBP__)
|
|
@end smallexample
|
|
|
|
@node VxWorks connection,,,
|
|
@subsubsection Connecting to VxWorks
|
|
|
|
The _GDBN__ command @samp{target} lets you connect to a VxWorks target on the
|
|
network. To connect to a target whose host name is ``@code{tt}'', type:
|
|
|
|
@smallexample
|
|
(_GDBP__) target vxworks tt
|
|
@end smallexample
|
|
|
|
_GDBN__ will display a message similar to the following:
|
|
|
|
@smallexample
|
|
Attaching remote machine across net... Success!
|
|
@end smallexample
|
|
|
|
_GDBN__ will then attempt to read the symbol tables of any object
|
|
modules loaded into the VxWorks target since it was last booted.
|
|
_GDBN__ locates these files by searching the directories listed in the
|
|
command search path (@pxref{Environment}); if it fails to find an
|
|
object file, it will display a message such as:
|
|
|
|
@smallexample
|
|
prog.o: No such file or directory.
|
|
@end smallexample
|
|
|
|
This will cause the @samp{target} command to abort. When this happens,
|
|
you should add the appropriate directory to the search path, with the
|
|
_GDBN__ command @samp{path}, and execute the @samp{target} command
|
|
again.
|
|
|
|
@node VxWorks download,,,
|
|
@subsubsection VxWorks Download
|
|
|
|
If you have connected to the VxWorks target and you want to debug an
|
|
object that has not yet been loaded, you can use the _GDBN__ @samp{load}
|
|
command to download a file from UNIX to VxWorks incrementally. The
|
|
object file given as an argument to the @samp{load} command is actually
|
|
opened twice: first by the VxWorks target in order to download the code,
|
|
then by _GDBN__ in order to read the symbol table. This can lead to
|
|
problems if the current working directories on the two systems differ.
|
|
It is simplest to set the working directory on both systems to the
|
|
directory in which the object file resides, and then to reference the
|
|
file by its name, without any path. Thus, to load a program
|
|
@samp{prog.o}, residing in @code{wherever/vw/demo/rdb}, on VxWorks type:
|
|
|
|
@smallexample
|
|
-> cd "wherever/vw/demo/rdb"
|
|
@end smallexample
|
|
|
|
On _GDBN__ type:
|
|
|
|
@smallexample
|
|
(_GDBP__) cd wherever/vw/demo/rdb
|
|
(_GDBP__) load prog.o
|
|
@end smallexample
|
|
|
|
_GDBN__ will display a response similar to the following:
|
|
|
|
@smallexample
|
|
Reading symbol data from wherever/vw/demo/rdb/prog.o... done.
|
|
@end smallexample
|
|
|
|
You can also use the @samp{load} command to reload an object module
|
|
after editing and recompiling the corresponding source file. Note that
|
|
this will cause _GDBN__ to delete all currently-defined breakpoints,
|
|
auto-displays, and convenience variables, and to clear the value
|
|
history. (This is necessary in order to preserve the integrity of
|
|
debugger data structures that reference the target system's symbol
|
|
table.)
|
|
|
|
@node VxWorks attach,,,
|
|
@subsubsection Running Tasks
|
|
|
|
You can also attach to an existing task using the @samp{attach} command as
|
|
follows:
|
|
|
|
@smallexample
|
|
(_GDBP__) attach @var{taskId}
|
|
@end smallexample
|
|
|
|
where @var{taskId} is the VxWorks hexadecimal task ID. The task can be running
|
|
or suspended when you attach to it. If running, it will be suspended at
|
|
the time of attachment.
|
|
|
|
_fi__(_VXWORKS__)
|
|
|
|
@node Leaving _GDBN__,,,
|
|
@section Leaving _GDBN__
|
|
@cindex exiting _GDBN__
|
|
@kindex quit
|
|
To exit _GDBN__, use the @samp{quit} command (abbreviated @samp{q}), or type
|
|
an end-of-file character (usually @kbd{C-d}).
|
|
|
|
@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 @samp{detach} command; @pxref{Attach}.
|
|
|
|
@node Shell Commands,,,
|
|
@section Shell Commands
|
|
If you just need to execute occasional shell commands during your
|
|
debugging session, there's no need to leave or suspend _GDBN__; you can
|
|
just use the @samp{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}.
|
|
The environment variable @code{SHELL} is used if it exists, otherwise _GDBN__
|
|
uses @samp{/bin/sh}.
|
|
@end table
|
|
|
|
The utility @samp{make} is often needed in development environments.
|
|
You don't have to use the @samp{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,,,
|
|
@chapter _GDBN__ Commands
|
|
|
|
@node Command Syntax,,,
|
|
@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
|
|
@samp{step} accepts an argument which is the number of times to step,
|
|
as in @samp{step 5}. You can also use the @samp{step} command with
|
|
no arguments. Some command names do not allow any arguments.
|
|
|
|
@cindex abbreviation
|
|
_GDBN__ command names may always be truncated if that abbreviation is
|
|
unambiguous. Other possible command abbreviations are listed in the
|
|
documentation for individual commands. Sometimes even ambiguous
|
|
abbreviations are allowed; for example, @samp{s} is specially defined as
|
|
equivalent to @samp{step} even though there are other commands whose
|
|
names start with @samp{s}.
|
|
|
|
@cindex repeating commands
|
|
A blank line as input to _GDBN__ means to repeat the previous command.
|
|
Certain commands (for example, @samp{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 @samp{list} and @samp{x} commands construct new arguments when
|
|
repeated, rather than repeating exactly as typed, to permit easy
|
|
scanning of source or memory.
|
|
|
|
@kindex #
|
|
@cindex comment
|
|
A line of input starting with @samp{#} is a comment; it does nothing.
|
|
This is useful mainly in command files (@xref{Command Files}).
|
|
|
|
@node Help,,,
|
|
@section Getting Help
|
|
@cindex online documentation
|
|
@kindex help
|
|
You can always ask _GDBN__ itself for information on its commands, using the
|
|
command @samp{help}.
|
|
|
|
@table @code
|
|
@item help
|
|
Used with no arguments, @samp{help} displays a short list of named
|
|
categories of commands:
|
|
@smallexample
|
|
(_GDBP__) help
|
|
List of classes of commands:
|
|
|
|
running -- Running the program
|
|
stack -- Examining the stack
|
|
data -- Examining data
|
|
breakpoints -- Making program stop at certain points
|
|
files -- Specifying and examining files
|
|
status -- Status inquiries
|
|
support -- Support facilities
|
|
user-defined -- User-defined commands
|
|
aliases -- Aliases of other commands
|
|
obscure -- Obscure features
|
|
|
|
Type "help" followed by a class name for a list of commands in that class.
|
|
Type "help" followed by command name for full documentation.
|
|
Command name abbreviations are allowed if unambiguous.
|
|
(_GDBP__)
|
|
@end smallexample
|
|
|
|
@item help @var{category}
|
|
Using one of the general help categories as an argument, you can get a
|
|
list of the individual commands in a category. For example, here is the
|
|
help display for category @samp{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 @samp{help} argument, _GDBN__ will display a
|
|
short paragraph on how to use that command.
|
|
@end table
|
|
|
|
In addition to @samp{help}, you can use the _GDBN__ commands @samp{info}
|
|
and @samp{show} to inquire about the state of your program, or the state
|
|
of _GDBN__ itself. Both commands support many ``sub-commands'', or
|
|
topics of inquiry; this manual introduces each of them in the
|
|
appropriate context. The listings under ``@code{info}'' and under
|
|
``@code{show}'' in the Index point to all the sub-commands.
|
|
@c FIXME: @pxref{Index} used to be here, but even though it shows up in
|
|
@c FIXME...the 'aux' file with a pageno the xref can't find it.
|
|
|
|
@table @code
|
|
@kindex info
|
|
@item info
|
|
This command is for describing the state of your program; for example,
|
|
it can list the arguments given to your program (@samp{info args}), the
|
|
registers currently in use (@samp{info registers}), or the breakpoints
|
|
you've set (@samp{info breakpoints}). You can get a complete list of
|
|
the @code{info} sub-commands with @samp{help info}.
|
|
|
|
@kindex show
|
|
@item show
|
|
In contrast, @samp{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 @samp{set}; for example, you can control what number
|
|
system is used for displays with @samp{set radix}, or simply inquire
|
|
which is currently in use with @samp{show radix}.
|
|
|
|
@kindex info set
|
|
To display all the settable parameters and their current
|
|
values, you can use @samp{show} with no arguments; you may also use
|
|
@samp{info set}. Both commands produce the same display.
|
|
@c FIXME: "info set" violates the rule that "info" is for state of
|
|
@c FIXME...program. Ck w/ GNU: "info set" to be called something else,
|
|
@c FIXME...or change desc of rule---eg "state of prog and debugging session"?
|
|
@end table
|
|
|
|
Here are three miscellaneous @samp{show} subcommands, all of which are
|
|
exceptional in lacking corresponding @samp{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,,,
|
|
@chapter Running Programs Under _GDBN__
|
|
|
|
@node Compilation,,,
|
|
@section Compiling for Debugging
|
|
|
|
In order to debug a program most 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,,,
|
|
@section Starting your Program
|
|
@cindex starting
|
|
@cindex running
|
|
@kindex run
|
|
To start your program under _GDBN__, use the @samp{run} command.
|
|
_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 @samp{file} or @samp{exec-file}
|
|
command (@pxref{Files}).@refill
|
|
|
|
On targets that support processes, @samp{run} creates an inferior
|
|
process and makes that process run your program. On other targets,
|
|
@samp{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
|
|
@samp{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
|
|
(for example regular expression expansion or variable substitution) in
|
|
describing the arguments. In Unix systems, you can control which shell
|
|
is used with the @code{SHELL} environment variable.
|
|
|
|
@item The @i{environment.}
|
|
Your program normally inherits its environment from _GDBN__, but you can
|
|
use the _GDBN__ commands @samp{set environment} and @samp{unset
|
|
environment} to change parts of the environment that will be given to
|
|
the program.@refill
|
|
|
|
@item The @i{working directory.}
|
|
Your program inherits its working directory from _GDBN__. You can set
|
|
_GDBN__'s working directory with the @samp{cd} command in _GDBN__.
|
|
|
|
@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 @samp{tty} command to
|
|
set a different device for your program.
|
|
@end table
|
|
|
|
When you issue the @samp{run} command, your program begins to execute
|
|
immediately. @xref{Stopping}, for discussion of how to arrange for your
|
|
program to stop.
|
|
|
|
Note that once your program has been started by the @samp{run} command,
|
|
you may evaluate expressions that involve calls to functions in the
|
|
inferior, using the @samp{print} or @samp{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,,,
|
|
@section Your Program's Arguments
|
|
|
|
@cindex arguments (to your program)
|
|
The arguments to your program can be specified by the arguments of the
|
|
@samp{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 @samp{/bin/sh}.
|
|
|
|
@samp{run} with no arguments uses the same arguments used by the previous
|
|
@samp{run}, or those set by the @samp{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
|
|
@samp{set args} has no arguments, @samp{run} will execute your program
|
|
with no arguments. Once you have run your program with arguments, this
|
|
is the only way to run it again without arguments.
|
|
|
|
@item show args
|
|
@kindex show args
|
|
Show the arguments to give your program when it is started.
|
|
@end table
|
|
|
|
@node Environment,,,
|
|
@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 a 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 the current working directory.
|
|
|
|
This command will not repeat if you press @key{RET} a second time after
|
|
using it once.
|
|
|
|
@item show environment @var{varname}
|
|
@kindex show environment
|
|
Print the value of environment variable @var{varname} to be given to
|
|
your program when it starts.
|
|
|
|
@item show environment
|
|
Print the names and values of all environment variables to be given to
|
|
your program.
|
|
|
|
@item set environment @var{varname} @var{value}
|
|
@itemx set environment @var{varname} = @var{value}
|
|
@kindex set environment
|
|
Sets environment variable @var{varname} to @var{value}. The value
|
|
changes for your program only, not for _GDBN__ itself. @var{value} may
|
|
be any string; the values of environment variables are just strings, and
|
|
any interpretation is supplied by your program itself. The @var{value}
|
|
parameter is optional; if it is eliminated, the variable is set to a
|
|
null value.
|
|
@c FIXME: I think "any string" here doesn't include leading, trailing
|
|
@c FIXME... blanks. Queried J Gilmore. ---pesch@cygnus.com, 4apr91
|
|
|
|
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}.
|
|
|
|
@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}=};
|
|
@samp{unset environment} removes the variable from the environment,
|
|
rather than assigning it an empty value.
|
|
@end table
|
|
|
|
@node Working Directory,,,
|
|
@section Your Program's Working Directory
|
|
|
|
@cindex working directory (of your program)
|
|
Each time you start your program with @samp{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 @samp{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,,,
|
|
@section Your Program's Input and Output
|
|
|
|
@cindex redirection
|
|
@cindex i/o
|
|
@cindex terminal
|
|
@cindex controlling terminal
|
|
By default, the program you run under _GDBN__ does input and output to the same
|
|
terminal that _GDBN__ uses.
|
|
|
|
You can redirect the program's input and/or output using shell
|
|
redirection with the @samp{run} command. For example,
|
|
|
|
_0__@example
|
|
run > outfile
|
|
_1__@end example
|
|
|
|
@noindent
|
|
starts the program, diverting its output to the file @file{outfile}.
|
|
|
|
@kindex tty
|
|
Another way to specify where the program should do input and output is
|
|
with the @samp{tty} command. This command accepts a file name as
|
|
argument, and causes this file to be the default for future @samp{run}
|
|
commands. It also resets the controlling terminal for the child
|
|
process, for future @samp{run} commands. For example,
|
|
|
|
@example
|
|
tty /dev/ttyb
|
|
@end example
|
|
|
|
@noindent
|
|
directs that processes started with subsequent @samp{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 @samp{run} overrides the @samp{tty} command's
|
|
effect on input/output redirection, but not its effect on the
|
|
controlling terminal.
|
|
|
|
When you use the @samp{tty} command or redirect input in the @samp{run}
|
|
command, only the input @emph{for your program} is affected. The input
|
|
for _GDBN__ still comes from your terminal.
|
|
|
|
@node Attach,,,
|
|
@section Debugging an Already-Running Process
|
|
@kindex attach
|
|
@cindex attach
|
|
|
|
@table @code
|
|
@item attach @var{process-id}
|
|
If your currently selected target supports processes, this command
|
|
attaches to a running process---one that was started outside _GDBN__.
|
|
(@samp{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 @code{jobs -l}
|
|
shell command.
|
|
|
|
@samp{attach} will not repeat if you press @key{RET} a second time after
|
|
executing the command.
|
|
@end table
|
|
|
|
To use @samp{attach}, you must have permission to send the process a
|
|
signal, and it must have the same effective user ID as the _GDBN__
|
|
process.
|
|
|
|
When using @samp{attach}, you should first use the @samp{file} command
|
|
to specify the program running in the process and load its symbol table.
|
|
|
|
The first thing _GDBN__ does after arranging to debug the specified
|
|
process is to stop it. You can examine and modify an attached process
|
|
with all the _GDBN__ commands that ordinarily available when you start
|
|
processes with @samp{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 @samp{continue} command after
|
|
attaching _GDBN__ to the process.
|
|
|
|
@kindex detach
|
|
When you have finished debugging the attached process, you can use the
|
|
@samp{detach} command to release it from _GDBN__'s control. Detaching
|
|
the process continues its execution. After the @samp{detach} command,
|
|
that process and _GDBN__ become completely independent once more, and you
|
|
are ready to @samp{attach} another process or start one with @samp{run}.
|
|
@samp{detach} will not repeat if you press @key{RET} again after using
|
|
it once.
|
|
|
|
If you exit _GDBN__ or use the @samp{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 this happens by using the @samp{set caution} command
|
|
(@pxref{Messages/Warnings}).
|
|
|
|
@group
|
|
@node Kill Process,,,
|
|
@section Killing the Child Process
|
|
|
|
@table @code
|
|
@item kill
|
|
@kindex kill
|
|
Kill the child process in which your program is running under _GDBN__.
|
|
@end table
|
|
|
|
This command is useful if you wish to debug a core dump instead of a
|
|
running process. _GDBN__ ignores any core dump file while your program
|
|
is running.
|
|
@end group
|
|
|
|
On some operating systems, you can't execute your program in another
|
|
process while breakpoints are active inside _GDBN__. You can use the
|
|
@samp{kill} command in this situation to permit running the program
|
|
outside the debugger.
|
|
|
|
The @samp{kill} command is also useful if you wish to recompile and
|
|
relink the program, since on many systems it is impossible to modify an
|
|
executable file which is running in a process. In this case, when you
|
|
next type @samp{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,,,
|
|
@chapter Stopping and Continuing
|
|
|
|
When you run a program normally, it runs until it terminates. The
|
|
principal purpose of using a debugger is so that you can stop it before
|
|
that point; or so that if the program runs into trouble you can
|
|
investigate and find out why.
|
|
|
|
@node Breakpoints,,,
|
|
@section Breakpoints
|
|
|
|
@cindex breakpoints
|
|
A @dfn{breakpoint} makes your program stop whenever a certain point in the
|
|
program is reached. You set breakpoints explicitly with _GDBN__ commands,
|
|
specifying the place where the program should stop by line number, function
|
|
name or exact address in the program. You can add various other conditions
|
|
to control whether the program will stop.
|
|
|
|
Each breakpoint is assigned a number when it is created; these numbers are
|
|
successive integers starting with 1. 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.
|
|
|
|
@node Set Breaks,,,
|
|
@subsection Setting Breakpoints
|
|
|
|
@kindex break
|
|
@kindex watch
|
|
Breakpoints are set with the @samp{break} command (abbreviated @samp{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}.
|
|
|
|
@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
|
|
Set 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 equivalent to a @samp{finish} command in the frame
|
|
inside the selected frame. If this is done in the innermost frame, _GDBN__
|
|
will stop the next time it reaches the current location; this may be
|
|
useful inside of loops.
|
|
|
|
_GDBN__ normally ignores breakpoints when it resumes execution, until at
|
|
least one instruction has been executed. If it did not do this, you
|
|
would be unable to proceed past a breakpoint without first disabling the
|
|
breakpoint. This rule applies whether or not the breakpoint already
|
|
existed when the program stopped.
|
|
|
|
@item break @dots{} if @var{cond}
|
|
Set a breakpoint with condition @var{cond}; evaluate the expression
|
|
@var{cond} each time the breakpoint is reached, and stop only if the
|
|
value is nonzero. @samp{@dots{}} stands for one of the possible
|
|
arguments described above (or no argument) specifying where to break.
|
|
@xref{Conditions}, for more information on breakpoint conditions.
|
|
|
|
@item tbreak @var{args}
|
|
@kindex tbreak
|
|
Set a breakpoint enabled only for one stop. @var{args} are the
|
|
same as in the @samp{break} command, and the breakpoint is set in the same
|
|
way, but the breakpoint is automatically disabled the first time it
|
|
is hit. @xref{Disabling}.
|
|
|
|
@item rbreak @var{regex}
|
|
@kindex rbreak
|
|
Set a breakpoint on all functions matching @var{regex}. This is
|
|
useful for setting breakpoints on overloaded functions that are not
|
|
members of any special classes. This command sets an unconditional
|
|
breakpoint on all matches, printing a list of all breakpoints it set.
|
|
Once these breakpoints are set, they are treated just like the
|
|
breakpoints set with the @samp{break} command. They can be deleted,
|
|
disabled, made conditional, etc., in the standard ways.
|
|
|
|
@kindex info breakpoints
|
|
@kindex $_
|
|
@item info breakpoints
|
|
The command @samp{info breakpoints} prints a list of all breakpoints 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. @samp{info break} with a
|
|
breakpoint number as argument lists only that breakpoint. The
|
|
convenience variable @code{$_} and the default examining-address for the
|
|
@samp{x} command are set to the address of the last breakpoint listed
|
|
(@pxref{Memory}).
|
|
@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,,,
|
|
@subsection Setting Watchpoints
|
|
@cindex watchpoints
|
|
A @dfn{watchpoint} is a special breakpoint that stops your program when
|
|
the value of an expression changes. You can use a watchpoint to stop
|
|
execution whenever the value of an expression changes, without having to
|
|
predict a particular place in the inferior process where this may
|
|
happen. Aside from the different syntax in setting a watchpoint, it is
|
|
managed exactly like any other breakpoint and is enabled, disabled, and
|
|
deleted using exactly the same commands.
|
|
|
|
Watchpoints currently execute two orders of magnitude more slowly than
|
|
other breakpoints, but this can well be worth it to catch errors where
|
|
you have no clue what part of your program is the culprit. Some
|
|
processors provide special hardware to implement this feature; future
|
|
releases of _GDBN__ will use such hardware if it is available.
|
|
|
|
@table @code
|
|
@kindex watch
|
|
@item watch @var{expr}
|
|
Set a watchpoint for an expression.
|
|
|
|
@kindex info watch
|
|
@item info watch
|
|
This command prints a list of watchpoints.
|
|
@end table
|
|
|
|
@node Exception Handling,,,
|
|
@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
|
|
|
|
Breakpoints can be set at active exception handlers by using the
|
|
@samp{catch} command. @var{exceptions} is a list of names of exceptions
|
|
to catch.
|
|
@end table
|
|
|
|
You can use @samp{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__ will normally return
|
|
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 @samp{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.
|
|
|
|
To stop just before an exception handler is called, you need some
|
|
knowledge of the implementation. In the case of GNU C++ exception are
|
|
raised by calling a library function named @code{__raise_exception}
|
|
which has the following ANSI C interface:
|
|
|
|
@example
|
|
/* ADDR is where the exception identifier is stored.
|
|
ID is the exception identifier. */
|
|
void __raise_exception (void **addr, void *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}). If you set a breakpoint in an exception handler
|
|
instead, it may not be easy to find out where the exception was raised.
|
|
|
|
With a conditional breakpoint (@xref{Conditions}) that depends on the
|
|
value of @code{id}, you can cause the debugger to stop only when a
|
|
specific exception is raised. Multiple conditional breakpoints can be
|
|
used to stop the program when any of a number of exceptions are raised.
|
|
|
|
@node Delete Breaks,,,
|
|
@subsection Deleting Breakpoints
|
|
|
|
@cindex clearing breakpoints, watchpoints
|
|
@cindex deleting breakpoints, watchpoints
|
|
It is often necessary to eliminate a breakpoint once it has done its job
|
|
and you no longer want the program to stop there. This is called
|
|
@dfn{deleting} the breakpoint. A breakpoint that has been deleted no
|
|
longer exists in any sense; it is forgotten.
|
|
|
|
With the @samp{clear} command you can delete breakpoints according to where
|
|
they are in the program. With the @samp{delete} command you can delete
|
|
individual breakpoints by specifying their breakpoint numbers.
|
|
|
|
It is not necessary to delete a breakpoint to proceed past it. _GDBN__
|
|
automatically ignores breakpoints on the first instruction to be executed
|
|
when you continue execution without changing the execution address.
|
|
|
|
@table @code
|
|
@item clear
|
|
@kindex clear
|
|
Delete any breakpoints at the next instruction to be executed in the
|
|
selected stack frame (@pxref{Selection}). When the innermost frame
|
|
is selected, this is a good way to delete a breakpoint that the program
|
|
just stopped at.
|
|
|
|
@item clear @var{function}
|
|
@itemx clear @var{filename}:@var{function}
|
|
Delete any breakpoints set at entry to the function @var{function}.
|
|
|
|
@item clear @var{linenum}
|
|
@itemx clear @var{filename}:@var{linenum}
|
|
Delete any breakpoints set at or within the code of the specified line.
|
|
|
|
@item delete breakpoints @var{bnums}@dots{}
|
|
@itemx delete @var{bnums}@dots{}
|
|
@itemx delete
|
|
@kindex delete breakpoints
|
|
@kindex delete
|
|
Delete the breakpoints of the numbers specified as arguments. If no
|
|
argument is specified, delete all breakpoints.
|
|
@end table
|
|
|
|
@node Disabling,,,
|
|
@subsection Disabling Breakpoints
|
|
|
|
@cindex disabled breakpoints
|
|
@cindex enabled breakpoints
|
|
Rather than deleting a breakpoint, 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 with the @samp{enable} and
|
|
@samp{disable} commands, optionally specifying one or more breakpoint
|
|
numbers as arguments. Use @samp{info break} to print a list of
|
|
breakpoints if you don't know which breakpoint numbers to use.
|
|
|
|
A breakpoint can have any of four different states of enablement:
|
|
|
|
@itemize @bullet
|
|
@item
|
|
Enabled. The breakpoint will stop the program. A breakpoint made
|
|
with the @samp{break} command starts out in this state.
|
|
@item
|
|
Disabled. The breakpoint has no effect on the program.
|
|
@item
|
|
Enabled once. The breakpoint will stop the program, but
|
|
when it does so it will become disabled. A breakpoint made
|
|
with the @samp{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 a breakpoint:
|
|
|
|
@table @code
|
|
@item disable breakpoints @var{bnums}@dots{}
|
|
@itemx disable @var{bnums}@dots{}
|
|
@itemx disable
|
|
@kindex disable breakpoints
|
|
@kindex disable
|
|
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.
|
|
|
|
@item enable breakpoints @var{bnums}@dots{}
|
|
@itemx enable @var{bnums}@dots{}
|
|
@itemx enable
|
|
@kindex enable breakpoints
|
|
@kindex enable
|
|
Enable the specified breakpoints (or all defined breakpoints). They
|
|
become effective once again in stopping the program, until you specify
|
|
otherwise.
|
|
|
|
@item enable breakpoints once @var{bnums}@dots{}
|
|
@itemx enable once @var{bnums}@dots{}
|
|
Enable the specified breakpoints temporarily. Each will be disabled
|
|
again the next time it stops the program (unless you have used one of
|
|
these commands to specify a different state before that time comes).
|
|
|
|
@item enable breakpoints delete @var{bnums}@dots{}
|
|
@itemx enable delete @var{bnums}@dots{}
|
|
Enable the specified breakpoints to work once and then die. Each of
|
|
the breakpoints will be deleted the next time it stops the program
|
|
(unless you have used one of these commands to specify a different
|
|
state before that time comes).
|
|
@end table
|
|
|
|
Save for a breakpoint set with @samp{tbreak} (@pxref{Set Breaks}),
|
|
breakpoints that you set initially enabled; subsequently, they become
|
|
disabled or enabled only when you use one of the commands above. (The
|
|
command @samp{until} can set and delete a breakpoint of its own, but it
|
|
will not change the state of your other breakpoints).
|
|
|
|
@node Conditions,,,
|
|
@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.
|
|
|
|
Break conditions may have side effects, and may even call functions in your
|
|
program. These may sound like strange things to do, but their effects are
|
|
completely predictable unless there is another enabled breakpoint at the
|
|
same address. (In that case, _GDBN__ might see the other breakpoint first and
|
|
stop the program without checking the condition of this one.) Note that
|
|
breakpoint commands are usually more convenient and flexible for the
|
|
purpose of performing side effects when a breakpoint is reached
|
|
(@pxref{Break Commands}).
|
|
|
|
Break conditions can be specified when a breakpoint is set, by using
|
|
@samp{if} in the arguments to the @samp{break} command. @xref{Set Breaks}.
|
|
They can also be changed at any time with the @samp{condition} command:
|
|
|
|
@table @code
|
|
@item condition @var{bnum} @var{expression}
|
|
@kindex condition
|
|
Specify @var{expression} as the break condition for breakpoint number
|
|
@var{bnum}. From now on, this breakpoint will stop the program only if
|
|
the value of @var{expression} is true (nonzero, in C). @var{expression}
|
|
is not evaluated at the time the @samp{condition} command is given.
|
|
When you call @samp{condition}, the expression you specify is checked
|
|
immediately for syntactic correctness, and to determine whether symbols
|
|
in it have referents in the context of your breakpoint.
|
|
@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 @samp{continue} is
|
|
ignored.
|
|
|
|
The synonym @samp{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,,,
|
|
@subsection Breakpoint Command Lists
|
|
|
|
@cindex breakpoint commands
|
|
You can give any breakpoint a series of commands to execute when the
|
|
program stops due to that breakpoint. For example, you might want to
|
|
print the values of certain expressions, or enable other breakpoints.
|
|
|
|
@table @code
|
|
@item commands @var{bnum}
|
|
@itemx @dots{} @var{command-list} @dots{}
|
|
@itemx end
|
|
@kindex commands
|
|
@kindex end
|
|
Specify a list of commands for breakpoint number @var{bnum}. The commands
|
|
themselves appear on the following lines. Type a line containing just
|
|
@samp{end} to terminate the commands.
|
|
|
|
To remove all commands from a breakpoint, use the command
|
|
@samp{commands} and follow it immediately by @samp{end}; that is, give
|
|
no commands.
|
|
|
|
With no arguments, @samp{commands} refers to the last breakpoint set
|
|
(not to the breakpoint most recently encountered).
|
|
@end table
|
|
|
|
Pressing @key{RET} as a means of repeating the last _GDBN__ command is
|
|
disabled from the time you enter @samp{commands} to just after the
|
|
corresponding @samp{end}.
|
|
|
|
You can use breakpoint commands to start the program up again. Simply
|
|
use the @samp{continue} command, or @samp{step}, or any other command to
|
|
resume execution. However, if you do this, any further commands in the
|
|
same breakpoint's command list are ignored. When the program stops
|
|
again, _GDBN__ will act according to the cause of that stop.
|
|
|
|
@kindex silent
|
|
If the first command specified is @samp{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. @samp{silent} is not really a command;
|
|
it is meaningful only at the beginning of the commands for a breakpoint.
|
|
|
|
The commands @samp{echo} and @samp{output} that allow you to print precisely
|
|
controlled output are often useful in silent breakpoints. @xref{Output}.
|
|
|
|
For example, here is how you could use breakpoint commands to print the
|
|
value of @code{x} at entry to @code{foo} whenever @code{x} is positive.
|
|
|
|
_0__@example
|
|
break foo if x>0
|
|
commands
|
|
silent
|
|
echo x is\040
|
|
output x
|
|
echo \n
|
|
cont
|
|
end
|
|
_1__@end example
|
|
|
|
One application for breakpoint commands is to correct one bug so you can
|
|
test another. Put a breakpoint just after the erroneous line of code, give
|
|
it a condition to detect the case in which something erroneous has been
|
|
done, and give it commands to assign correct values to any variables that
|
|
need them. End with the @samp{continue} command so that the program does not
|
|
stop, and start with the @samp{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
|
|
|
|
One deficiency in the operation of automatically continuing breakpoints
|
|
under Unix appears when your program uses raw mode for the terminal.
|
|
_GDBN__ switches back to its own terminal modes (not raw) before executing
|
|
commands, and then must switch back to raw mode when your program is
|
|
continued. This causes any pending terminal input to be lost.
|
|
In the GNU system, this will be fixed by changing the behavior of
|
|
terminal modes.
|
|
|
|
Under Unix, when you have this problem, you might be able to get around
|
|
it by putting your actions into the breakpoint condition instead of
|
|
commands. For example
|
|
|
|
@example
|
|
condition 5 (x = y + 4), 0
|
|
@end example
|
|
|
|
@noindent
|
|
specifies a condition expression (@xref{Expressions}) that will change
|
|
@code{x} as needed, then always have the value 0 so the program will not
|
|
stop. Loss of input is avoided here because break conditions are
|
|
evaluated without changing the terminal modes. When you want to have
|
|
nontrivial conditions for performing the side effects, the operators
|
|
@samp{&&}, @samp{||} and @samp{?@dots{}:} may be useful.
|
|
|
|
@node Error in Breakpoints,,,
|
|
@subsection ``Cannot Insert Breakpoints''
|
|
|
|
@c FIXME: "cannot insert breakpoints" error, v unclear.
|
|
@c Q in pending mail to Gilmore. ---pesch@cygnus.com, 26mar91
|
|
Under some operating systems, breakpoints cannot be used in a program if
|
|
any other process is running that program. In this situation,
|
|
attempting to run or continue a program with a breakpoint will cause _GDBN__
|
|
to stop the other process.
|
|
|
|
When this happens, you have three ways to proceed:
|
|
|
|
@enumerate
|
|
@item
|
|
Remove or disable the breakpoints, then continue.
|
|
|
|
@item
|
|
Suspend _GDBN__, and copy the file containing the program to a new name.
|
|
Resume _GDBN__ and use the @samp{exec-file} command to specify that _GDBN__
|
|
should run the program under that name. Then start the program again.
|
|
|
|
@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,,,
|
|
@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. Breakpoints are active during stepping
|
|
and the program will stop for them even if it has not gone as far as the
|
|
stepping command specifies.
|
|
|
|
@table @code
|
|
@item step
|
|
@kindex step
|
|
Continue running the program until control reaches a different source
|
|
line, then stop it and return control to the debugger. This command is
|
|
abbreviated @samp{s}.
|
|
|
|
This command may be given 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 @samp{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
|
|
Continue to the next source line in the current stack frame. Similar to
|
|
@samp{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
|
|
@samp{next} command was given. This command is abbreviated @samp{n}.
|
|
|
|
An argument is a repeat count, as in @samp{step}.
|
|
|
|
@samp{next} within a function that lacks debugging information acts as does
|
|
@samp{step}, but any function calls appearing within the code of the
|
|
function are executed without stopping.
|
|
@c FIXME: great; so what does *step* do within a fn that lacks debug info?
|
|
|
|
@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 @samp{return} command (@pxref{Returning}).
|
|
|
|
@item until
|
|
@kindex until
|
|
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 @samp{next}
|
|
command, except that when @samp{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, @samp{until} will cause the program to continue execution
|
|
until the loop is exited. In contrast, a @samp{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.
|
|
|
|
@samp{until} always stops the program if it attempts to exit the current
|
|
stack frame.
|
|
|
|
@samp{until} may produce somewhat counterintuitive results if the order
|
|
of the source lines does not match the actual order of execution. For
|
|
example, in a typical C @code{for}-loop, the third expression in the
|
|
@code{for}-statement (the loop-step expression) is executed after the
|
|
statements in the body of the loop, but is written before them.
|
|
Therefore, the @samp{until} command would appear to step back to the
|
|
beginning of the loop when it advances to this expression. However, it
|
|
has not really done so, not in terms of the actual machine code.
|
|
|
|
@samp{until} with no argument works by means of single
|
|
instruction stepping, and hence is slower than @samp{until} with an
|
|
argument.
|
|
|
|
@item until @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 @samp{break} (@pxref{Set
|
|
Breaks}). This form of the command uses breakpoints, and hence is
|
|
quicker than @samp{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 @samp{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 @samp{next}.
|
|
@end table
|
|
|
|
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.
|
|
|
|
The @samp{continue} command can be used after stepping to resume execution
|
|
until the next breakpoint or signal.
|
|
|
|
@node Continuing,,,
|
|
@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, @samp{continue}
|
|
takes special care to prevent that from happening. You do not need
|
|
to delete the breakpoint to proceed through it after stopping at it.
|
|
You can, however, specify an ignore-count for the breakpoint that the
|
|
program stopped at, by means of an argument to the @samp{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 @samp{handle} command (@pxref{Signals}).
|
|
|
|
@node Signals,,,
|
|
@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 @samp{handle} command.
|
|
|
|
@table @code
|
|
@item info signal
|
|
@kindex info signal
|
|
Print a table of all the kinds of signals and how _GDBN__ has been told to
|
|
handle each one. You can use this to see the signal numbers of all
|
|
the defined types of signals.
|
|
|
|
@item handle @var{signal} @var{keywords}@dots{}
|
|
@kindex handle
|
|
Change the way _GDBN__ handles signal @var{signal}. @var{signal} can be the
|
|
number of a signal or its name (with or without the @samp{SIG} at the
|
|
beginning). The @var{keywords} say what change to make.
|
|
@end table
|
|
|
|
@group
|
|
The keywords allowed by the @samp{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 @samp{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 @samp{nostop} keyword as well.
|
|
|
|
@item pass
|
|
_GDBN__ should allow the program to see this signal; the program will be
|
|
able to handle the signal, or may be terminated if the signal is fatal
|
|
and not handled.
|
|
|
|
@item nopass
|
|
_GDBN__ should not allow the program to see this signal.
|
|
@end table
|
|
@end group
|
|
|
|
When a signal has been set to stop the program, the program cannot see the
|
|
signal until you continue. It will see the signal then, if @samp{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 @samp{handle} command with
|
|
@samp{pass} or @samp{nopass} to control whether that signal will be seen by
|
|
the program when you later continue it.
|
|
|
|
You can also use the @samp{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,,,
|
|
@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 @samp{frame} command does
|
|
(@pxref{Frame Info, Info}).
|
|
|
|
@node Frames,,,
|
|
@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
|
|
@code{0} for the innermost frame, @code{1} 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 give it a virtual stack frame of 0 and
|
|
correctly allow tracing of the function call chain. Results are
|
|
undefined if a function invocation besides the innermost one is
|
|
frameless.
|
|
|
|
@node Backtrace,,,
|
|
@section Backtraces
|
|
|
|
A backtrace is a summary of how the program got where it is. It shows one
|
|
line per frame, for many frames, starting with the currently executing
|
|
frame (frame zero), followed by its caller (frame one), and on up the
|
|
stack.
|
|
|
|
@table @code
|
|
@item backtrace
|
|
@itemx bt
|
|
@kindex backtrace
|
|
@kindex bt
|
|
Print a backtrace of the entire stack: one line per frame for all
|
|
frames in the stack.
|
|
|
|
You can stop the backtrace at any time by typing the system interrupt
|
|
character, normally @kbd{Control-C}.
|
|
|
|
@item backtrace @var{n}
|
|
@itemx bt @var{n}
|
|
Similar, but print only the innermost @var{n} frames.
|
|
|
|
@item backtrace -@var{n}
|
|
@itemx bt -@var{n}
|
|
Similar, but print only the outermost @var{n} frames.
|
|
@end table
|
|
|
|
@kindex where
|
|
@kindex info stack
|
|
The names @samp{where} and @samp{info stack} are additional aliases
|
|
for @samp{backtrace}.
|
|
|
|
Each line in the backtrace shows the frame number and the function name.
|
|
The program counter value is also shown---unless you use @samp{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
|
|
#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 smallexample
|
|
|
|
@noindent
|
|
The display for frame @code{#0} 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,,,
|
|
@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.
|
|
|
|
@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
|
|
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.
|
|
@end table
|
|
|
|
All of these commands end by printing some information on the frame that
|
|
has been selected: the frame number, the function name, the arguments, the
|
|
source file and line number of execution in that frame, and 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 @samp{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 @samp{up} and @samp{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,,,
|
|
@section Information on 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 @samp{f}. With an
|
|
argument, this command is used to select a stack frame (@pxref{Selection}).
|
|
|
|
@item info frame
|
|
@kindex info frame
|
|
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}
|
|
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 @samp{up},
|
|
@samp{down}, or @samp{frame} commands); then type @samp{info catch}.
|
|
@xref{Exception Handling}.
|
|
@end table
|
|
|
|
@node Source,,,
|
|
@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 also
|
|
print parts 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}.
|
|
|
|
@node List,,,
|
|
@section Printing Source Lines
|
|
|
|
@kindex list
|
|
@kindex l
|
|
To print lines from a source file, use the @samp{list} command
|
|
(abbreviated @samp{l}). There are several ways to specify what part
|
|
of the file you want to print.
|
|
|
|
Here are the forms of the @samp{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
|
|
@samp{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 @samp{list} command with @key{RET} discards the argument,
|
|
so it is equivalent to typing just @samp{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 @samp{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 @samp{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 @samp{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 @samp{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,,,
|
|
@section Searching Source Files
|
|
@cindex searching
|
|
@kindex search
|
|
@kindex forward-search
|
|
@kindex reverse-search
|
|
|
|
There are two commands for searching through the current source file for a
|
|
regular expression.
|
|
|
|
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 @samp{fo}. The synonym @samp{search @var{regexp}} is also supported.
|
|
|
|
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 @samp{rev}.
|
|
|
|
@node Source Path,,,
|
|
@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 @samp{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{$cwd} to refer to the current working directory, and
|
|
@samp{$cdir} to refer to the compilation directory (if one is recorded).
|
|
|
|
@item directory
|
|
Reset the source path to empty again. This requires confirmation.
|
|
|
|
The @samp{directory} command will not repeat if you press @key{RET} a
|
|
second time after executing it once.
|
|
|
|
@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 @samp{directory} with no argument to reset the source path to empty.
|
|
|
|
@item
|
|
Use @samp{directory} with suitable arguments to add any other
|
|
directories you want in the source path. You can add all the directories
|
|
in one command.
|
|
@end enumerate
|
|
|
|
@node Machine Code,,,
|
|
@section Source and Machine Code
|
|
You can use the command @samp{info line} to map source lines to program
|
|
addresses, and the command @samp{disassemble} or its synonym
|
|
@samp{disasm} 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}.
|
|
|
|
@kindex $_
|
|
After @samp{info line}, the default address for the @samp{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}).
|
|
|
|
@kindex disassemble
|
|
@kindex disasm
|
|
@item disassemble
|
|
@itemx disasm
|
|
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. The two spellings, @samp{disasm} and
|
|
@samp{disassemble}, are equivalent.
|
|
@end table
|
|
|
|
@node Data,,,
|
|
@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 @samp{print}
|
|
command (abbreviated @samp{p}), or its synonym @samp{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 @samp{x} command.
|
|
It examines data in memory at a specified address and prints it in a
|
|
specified format. @xref{Memory}.
|
|
|
|
@node Expressions,,,
|
|
@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
|
|
officially supposed to reside at @var{addr}.@refill
|
|
@end table
|
|
|
|
@node Variables,,,
|
|
@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.
|
|
|
|
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 construct:
|
|
|
|
@cindex colon-colon
|
|
@cindex scope
|
|
@kindex ::
|
|
@example
|
|
@var{block}::@var{variable}
|
|
@end example
|
|
|
|
@noindent
|
|
Here @var{block} is the name of the source file whose variable you want.
|
|
|
|
@cindex name resolution (C++)
|
|
Unfortunately, this use of @samp{::} conflicts with the very similar use
|
|
of the same notation in C++; accordingly, _GDBN__ does not support use of
|
|
the C++ name resolution operator in _GDBN__ expressions.
|
|
|
|
@node Arrays,,,
|
|
@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 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,,,
|
|
@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
|
|
@samp{print} command with a slash and a format letter. The format
|
|
letters supported are:
|
|
|
|
@table @samp
|
|
@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 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 @samp{print} command with just a format and no
|
|
expression. For example, @samp{p/x} reprints the last value in hex.
|
|
|
|
@node Memory,,,
|
|
@section Examining Memory
|
|
|
|
@cindex examining memory
|
|
@table @code
|
|
@kindex x
|
|
@item x/@var{Nuf} @var{expr}
|
|
The command @samp{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. @samp{x} understands the formats
|
|
@var{f} used by @samp{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/3hu 0x54320} is a request to display three halfwords
|
|
(@code{h}) of memory, formatted as unsigned decimal integers (@code{u}),
|
|
starting at address @code{0x54320}. @samp{x/4wx $sp} prints the four
|
|
words (@code{w}) of memory above the stack pointer (here, @samp{$sp};
|
|
@pxref{Registers}) in hexadecimal (@code{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 indicate the address where _GDBN__
|
|
is to begin reading memory for display, using an expression. 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 @samp{x}:
|
|
|
|
@table @samp
|
|
@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 @samp{print}. @xref{Output formats}.
|
|
|
|
@samp{x} has two additional output specifications which derive the unit
|
|
size from the data inspected:
|
|
|
|
@table @samp
|
|
@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 @samp{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}, @samp{x}
|
|
will use the same one that was used last. If you don't use any letters
|
|
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 @samp{print} command shows a value that resides in memory,
|
|
@samp{print} also sets the default address for the @samp{x} command.
|
|
@samp{info line} also sets the default for @samp{x}, to the address of
|
|
the start of the machine code for the specified line (@pxref{Machine
|
|
Code}), and @samp{info breakpoints} sets it to the address of the last
|
|
breakpoint listed (@pxref{Set Breaks}).
|
|
|
|
When you use @key{RET} to repeat an @samp{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 @samp{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 @samp{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 @samp{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 @samp{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,,,
|
|
@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 @samp{x} or @samp{print}, you can
|
|
specify the output format you prefer; in fact, @dfn{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}.
|
|
|
|
@samp{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.
|
|
|
|
@samp{undisplay} will not repeat if you press @key{RET} after using it.
|
|
|
|
@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
|
|
@samp{display name} while inside a function with an argument
|
|
@code{name}, then this argument will be displayed while the program
|
|
continues to stop inside that function. When it stops elsewhere---where
|
|
there is no variable @samp{name}---display is disabled. The next time
|
|
your program stops where @samp{name} is meaningful, you can enable the
|
|
display expression once again.
|
|
|
|
@node Print Settings,,,
|
|
@section Print Settings
|
|
|
|
@cindex format options
|
|
@cindex print settings
|
|
_GDBN__ provides the following ways to control how arrays, structures,
|
|
and symbols are printed.
|
|
|
|
@table @code
|
|
@item set array-max @var{number-of-elements}
|
|
@kindex set array-max
|
|
If _GDBN__ is printing a large array, it will stop printing after it has
|
|
printed the number of elements set by the @samp{set array-max} command.
|
|
This limit also applies to the display of strings.
|
|
|
|
@item show array-max
|
|
@kindex show array-max
|
|
Display the number of elements of a large array that _GDBN__ will print
|
|
before losing patience.
|
|
|
|
@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 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 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.
|
|
|
|
@item set print address
|
|
@item set print address on
|
|
@kindex set print address
|
|
_GDBN__ will print memory addresses in stack traces, structure values, pointer
|
|
values, breakpoints, etc. The default is on.
|
|
|
|
@item set print address off
|
|
Do not print addresses.
|
|
|
|
@item show print address
|
|
@kindex show print address
|
|
Show whether or not addresses are to be printed.
|
|
|
|
@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 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 @samp{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 @samp{set print union off} in effect it would print
|
|
|
|
@smallexample
|
|
$1 = @{it = Tree, form = @{...@}@}
|
|
@end smallexample
|
|
@end table
|
|
|
|
@node Value History,,,
|
|
@section Value History
|
|
|
|
@cindex value history
|
|
Values printed by the @samp{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 @samp{file} or @samp{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 1. @samp{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 @samp{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 @samp{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 @samp{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 @samp{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.
|
|
@end table
|
|
|
|
@node Convenience Vars,,,
|
|
@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 have names starting with @samp{$}. Any name starting
|
|
with @samp{$} can be used for a convenience variable, unless it is one of
|
|
the predefined machine-specific register names (@pxref{Registers}).
|
|
|
|
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 @samp{i 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 @samp{x} command to
|
|
the last address examined (@pxref{Memory}). Other commands which
|
|
provide a default address for @samp{x} to examine also set @code{$_}
|
|
to that address; these commands include @samp{info line} and @samp{info
|
|
breakpoint}.
|
|
|
|
@item $__
|
|
The variable @code{$__} is automatically set by the @samp{x} command
|
|
to the value found in the last address examined.
|
|
@end table
|
|
|
|
@node Registers,,,
|
|
@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 @samp{info registers} to see the names used on
|
|
your machine. The names @code{$pc} and @code{$sp} are used on most
|
|
machines for the program counter register and the stack pointer. 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 @samp{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 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.
|
|
|
|
@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
|
|
|
|
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 @samp{return};
|
|
@pxref{Returning}.)
|
|
|
|
@node Symbols,,,
|
|
@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, as 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}. @samp{ptype}
|
|
differs from @samp{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 sources
|
|
@kindex info sources
|
|
Print the names of all source files in the program for which there
|
|
is debugging information.
|
|
|
|
@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 @samp{step}; @samp{info fun ^step} finds those whose names
|
|
start with @samp{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 @samp{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 @samp{ptype} command can be overwhelming and hard to use. The
|
|
@samp{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,,,
|
|
@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.
|
|
|
|
@node Assignment,,,
|
|
@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
|
|
@samp{set} command instead of the @samp{print} command. @samp{set} is
|
|
really the same as @samp{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 @samp{set} command
|
|
appears identical to a @samp{set} subcommand, use the @samp{set
|
|
variable} command instead of just @samp{set}. This command is identical
|
|
to @samp{set} except for its lack of subcommands.
|
|
|
|
_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,,,
|
|
@section Continuing at a Different Address
|
|
|
|
Ordinarily, when you continue the program, you do so at the place where
|
|
it stopped, with the @samp{continue} command. You can instead continue at
|
|
an address of your own choosing, with the following commands:
|
|
|
|
@table @code
|
|
@item jump @var{linenum}
|
|
@kindex jump
|
|
Resume execution at line number @var{linenum}. Execution will stop
|
|
immediately if there is a breakpoint there.
|
|
|
|
The @samp{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{linenum} 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 @samp{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 @samp{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 @samp{jump} command is to back up,
|
|
perhaps with more breakpoints set, over a portion of a program that has
|
|
already executed.
|
|
|
|
@group
|
|
@node Signaling,,,
|
|
@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
|
|
@samp{continue} command; @samp{signal 0} causes it to resume without a
|
|
signal.
|
|
|
|
This command does not repeat when you press @key{RET} a second time
|
|
after using it once.
|
|
@end table
|
|
@end group
|
|
|
|
@node Returning,,,
|
|
@section Returning from a Function
|
|
|
|
@table @code
|
|
@item return
|
|
@cindex returning from a function
|
|
@kindex return
|
|
You can cancel execution of a function call with the @samp{return}
|
|
command.
|
|
@end table
|
|
|
|
This command abandons execution of a function. 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 @samp{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 @samp{finish} command (@pxref{Stepping})
|
|
resumes execution until the selected stack frame returns naturally.
|
|
|
|
@node Calling,,,
|
|
@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 @samp{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 GDB Files,,,
|
|
@chapter _GDBN__'s Files
|
|
|
|
@node 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 @samp{run} command. If you do not specify a
|
|
directory and the file is not found in _GDBN__'s working directory,
|
|
|
|
_GDBN__ will use 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.
|
|
|
|
@samp{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 @samp{file} command to get both symbol
|
|
table and program to run from the same file.
|
|
|
|
@samp{symbol-file} with no argument clears out _GDBN__'s information on your
|
|
program's symbol table.
|
|
|
|
The @samp{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__.
|
|
|
|
@samp{symbol-file} will not repeat if you press @key{RET} again after
|
|
executing it once.
|
|
|
|
On some kinds of object files, the @samp{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 @samp{set verbose} command can turn these pauses into
|
|
messages if desired. @xref{Messages/Warnings}).
|
|
|
|
When the symbol table is stored in COFF format, @samp{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.
|
|
|
|
@samp{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 @samp{kill} command
|
|
(@pxref{Kill Process}).
|
|
|
|
@item load @var{filename}
|
|
@kindex load
|
|
_if__(_GENERIC__)
|
|
Depending on what remote debugging facilities are configured into
|
|
_GDBN__, the @samp{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.
|
|
@samp{load} also records @var{filename}'s symbol table in _GDBN__, like
|
|
the @samp{add-symbol-file} command.
|
|
|
|
If @samp{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, @samp{load} will dynamically link @var{filename} on the
|
|
current target system as well as adding its symbols in _GDBN__.
|
|
_fi__(_VXWORKS__)
|
|
|
|
_if__(_I960__)
|
|
With the Nindy interface to an Intel 960 board, @samp{load} will
|
|
download @var{filename} to the 960 as well as adding its symbols in
|
|
_GDBN__.
|
|
_fi__(_I960__)
|
|
|
|
@samp{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 @samp{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 @samp{symbol-file} command. You can use the
|
|
@samp{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 @samp{symbol-file} command.
|
|
|
|
@samp{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
|
|
@samp{info files} and @samp{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 @samp{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 @samp{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 are currently loaded.
|
|
@end table
|
|
|
|
@samp{sharedlibrary} does not repeat automatically when you press
|
|
@key{RET} after using it once.
|
|
|
|
@node Symbol Errors,,,
|
|
@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 @samp{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 @samp{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
|
|
@samp{complain}, then go up to the function @samp{read_dbx_symtab} and
|
|
examine @code{*bufp} to see the symbol.
|
|
|
|
@c @item stub type has NULL name
|
|
@c
|
|
@c FIXME, Mike Tiemann needs to write about what this means.
|
|
|
|
@item const/volatile indicator missing, got 'X'
|
|
|
|
The symbol information for a C++ type is missing some information that
|
|
the compiler should have output for it.
|
|
|
|
@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,,,
|
|
@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 @samp{file} or @samp{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 @samp{target} command.
|
|
|
|
@node Active 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 @samp{detach}
|
|
command. The related command @samp{attach} provides you with a way of
|
|
choosing a particular running process as a new target. @xref{Attach}.
|
|
|
|
@node Target Commands,,,
|
|
@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 @samp{target} command will not repeat if you press @key{RET} again
|
|
after executing the command.
|
|
|
|
@item help targets
|
|
@kindex help targets
|
|
Displays the names of all targets available. To display targets
|
|
currently selected, use either @samp{info target} or @samp{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.
|
|
@code{/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 @samp{target remote};
|
|
@samp{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.
|
|
@samp{/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,,,
|
|
@section Remote Debugging
|
|
@cindex remote debugging
|
|
|
|
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 be debugging an operating system kernel, or debugging
|
|
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 adapt.
|
|
|
|
To use the _GDBN__ remote serial protocol, the program to be debugged on
|
|
the remote machine needs to contain a debugging device driver which
|
|
talks to _GDBN__ over the serial line. Several sample remote debugging
|
|
drivers 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 @samp{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 @samp{detach}
|
|
command.
|
|
|
|
Other remote targets may be available in your
|
|
configuration of _GDBN__; use @samp{help targets} to list them.
|
|
|
|
@node Controlling _GDBN__,,,
|
|
@chapter Controlling _GDBN__
|
|
|
|
You can alter many aspects of _GDBN__'s interaction with you by using
|
|
the @samp{set} command. For commands controlling how _GDBN__ displays
|
|
data, @pxref{Print Settings}; other settings are described here.
|
|
|
|
@node Prompt,,,
|
|
@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 @samp{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 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,,,
|
|
@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 @samp{emacs}-style
|
|
or @samp{vi}-style inline editing of commands, @samp{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 @samp{set}. You may check the status of any of these settings
|
|
with the command @samp{show}.
|
|
|
|
@table @code
|
|
@kindex set editing
|
|
@cindex editing
|
|
@item set editing
|
|
@itemx set editing on
|
|
Enable command line editing (enabled by default).
|
|
|
|
@item set editing off
|
|
Disable command line editing.
|
|
|
|
@kindex show editing
|
|
@item show editing
|
|
Show whether command line editing is enabled.
|
|
|
|
@node History,,,
|
|
@section Command History
|
|
@cindex history substitution
|
|
@cindex history file
|
|
@kindex set history file
|
|
@item set history file @var{filename}
|
|
Set the name of the _GDBN__ command history file to @var{filename}. 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 write
|
|
@kindex set history write
|
|
@item set history write
|
|
@itemx set history write on
|
|
Record command history in a file, whose name may be specified with the
|
|
@samp{set history file} command. By default, this option is disabled.
|
|
|
|
@item set history write 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 @samp{!}.
|
|
@iftex
|
|
(@xref{Event Designators}.)
|
|
@end iftex
|
|
Since @samp{!} is also the logical not operator in C, history expansion
|
|
is off by default. If you decide to enable history expansion with the
|
|
@samp{set history expansion on} command, you may sometimes need to
|
|
follow @samp{!} (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
|
|
@samp{!=} and @samp{!(}, 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 @samp{emacs}
|
|
or @samp{vi} may wish to read it.
|
|
@iftex
|
|
@xref{Command Line Editing}.
|
|
@end iftex
|
|
|
|
@group
|
|
@kindex show history
|
|
@item show history
|
|
@itemx show history file
|
|
@itemx show history write
|
|
@itemx show history size
|
|
@itemx show history expansion
|
|
These commands display the state of the _GDBN__ history parameters.
|
|
@samp{show history} by itself displays all four states.
|
|
@end group
|
|
|
|
@end table
|
|
|
|
@table @code
|
|
@kindex show commands
|
|
@item show commands
|
|
Display the last ten commands in the command history.
|
|
|
|
@item show commands @var{n}
|
|
Print ten commands centered on command number @var{n}.
|
|
|
|
@item show commands +
|
|
Print ten commands just after the commands last printed.
|
|
|
|
@end table
|
|
|
|
@node Screen Size,,,
|
|
@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 @samp{set height} and @samp{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 @samp{set} commands specify a screen height of @var{lpp} lines and
|
|
a screen width of @var{cpl} characters. The associated @samp{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,,,
|
|
@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 @samp{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,,,
|
|
@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 @samp{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 @samp{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
|
|
@samp{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 @samp{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 @samp{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. 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.
|
|
@xref{Symbol Errors}.
|
|
|
|
@table @code
|
|
@kindex set complaints
|
|
@item set complaints @var{limit}
|
|
Permits _GDBN__ to output @var{limit} complaints about each type of unusual
|
|
symbols before becoming silent about the problem. Set @var{limit} to
|
|
zero to suppress all complaints; set it to a large number to prevent
|
|
complaints from being suppressed.
|
|
|
|
@kindex show complaints
|
|
@item show complaints
|
|
Displays how many symbol complaints _GDBN__ is permitted to produce.
|
|
@end table
|
|
|
|
By default, _GDBN__ is cautious, and asks what sometimes seem to be a lot of
|
|
stupid questions. 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 caution
|
|
@cindex flinching
|
|
@cindex stupid questions
|
|
@item set caution off
|
|
Disables cautious questions.
|
|
|
|
@item set caution on
|
|
Enables cautious questions (the default).
|
|
|
|
@item show caution
|
|
@kindex show caution
|
|
Displays state of cautious questions.
|
|
@end table
|
|
|
|
@node Sequences,,,
|
|
@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.
|
|
|
|
@node Define,,,
|
|
@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 @samp{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 @samp{define} command. The end of these
|
|
commands is marked by a line containing @samp{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 @samp{define} reads the lines of the
|
|
command definition, ending with @samp{end}. After the @samp{document}
|
|
command is finished, @samp{help} on command @var{commandname} will print
|
|
the documentation you have specified.
|
|
|
|
You may use the @samp{document} command again to change the
|
|
documentation of a command. Redefining the command with @samp{define}
|
|
does not change the documentation.
|
|
@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,,,
|
|
@section Command Files
|
|
|
|
@cindex command files
|
|
A command file for _GDBN__ is a file of lines that are _GDBN__ commands. Comments
|
|
(lines starting with @samp{#}) 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 the @samp{-nx} option is given.) You can also request the
|
|
execution of a command file with the @samp{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,,,
|
|
@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 @samp{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,,,
|
|
@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__ @samp{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 @samp{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__ @samp{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 ``@code{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 @samp{.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__ @samp{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__ @samp{next} command. Then update the display window
|
|
to show the current file and location.
|
|
|
|
@item M-i
|
|
Execute one instruction, like the _GDBN__ @samp{stepi} command; update
|
|
display window accordingly.
|
|
|
|
@item M-x gdb-nexti
|
|
Execute to next instruction, using the _GDBN__ @samp{nexti} command; update
|
|
display window accordingly.
|
|
|
|
@item C-c C-f
|
|
Execute until exit from the selected stack frame, like the _GDBN__
|
|
@samp{finish} command.
|
|
|
|
@item M-c
|
|
@c C-c C-p in emacs 19
|
|
Continue execution of the program, like the _GDBN__ @samp{continue} command.
|
|
|
|
@item M-u
|
|
@c C-c C-u in emacs 19
|
|
Go up the number of frames indicated by the numeric argument
|
|
(@pxref{Arguments, , Numeric Arguments, emacs, The GNU Emacs Manual}),
|
|
like the _GDBN__ @samp{up} command.@refill
|
|
|
|
@item M-d
|
|
@c C-c C-d in emacs 19
|
|
Go down the number of frames indicated by the numeric argument, like the
|
|
_GDBN__ @samp{down} command.
|
|
|
|
@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 @samp{disassemble} by typing @kbd{C-x &}.
|
|
|
|
You can customize this further on the fly by defining elements of the list
|
|
@samp{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 @samp{format}; otherwise the number
|
|
is passed as an argument to the corresponding list element.
|
|
|
|
@item M-x gdb-display-frame
|
|
Explicitly request display of the source code surrounding the current
|
|
frame location, in another window. _GDBN__ does this display automatically;
|
|
but if, for example, you accidentally kill the buffer where it is
|
|
displayed, this command is a way of getting it back.
|
|
@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.
|
|
|
|
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 @samp{epoch}
|
|
environment. Users of this environment can use a new command,
|
|
@samp{inspect} which performs identically to @samp{print} except that
|
|
each value is printed in its own window.
|
|
@end ignore
|
|
|
|
@node _GDBN__ Bugs,,,
|
|
@c node-name, next, previous, up
|
|
@chapter Reporting Bugs in _GDBN__
|
|
@cindex Bugs in _GDBN__
|
|
@cindex Reporting Bugs in _GDBN__
|
|
|
|
Your bug reports play an essential role in making _GDBN__ reliable.
|
|
|
|
Reporting a bug may help you by bringing a solution to your problem, or it
|
|
may not. But in any case the principal function of a bug report is to help
|
|
the entire community by making the next version of _GDBN__ work better. Bug
|
|
reports are your contribution to the maintenance of _GDBN__.
|
|
|
|
In order for a bug report to serve its purpose, you must include the
|
|
information that enables us to fix the bug.
|
|
|
|
@node Bug Criteria,,,
|
|
@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,,,
|
|
@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 @samp{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 does not contain 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 @samp{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 would 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.
|
|
|
|
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 readline/inc-readline.texinfo
|
|
@include readline/inc-history.texinfo
|
|
@end iftex
|
|
|
|
@node Installing _GDBN__,,,
|
|
@appendix Installing _GDBN__
|
|
@cindex configuring _GDBN__
|
|
@cindex installation
|
|
|
|
The script @samp{config.gdb} automates the process of preparing _GDBN__
|
|
for installation; you can then use @samp{make} to actually build it.
|
|
The best way to build GDB 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.
|
|
@samp{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 License,,,
|
|
@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,,,
|
|
@unnumbered Index
|
|
|
|
@printindex cp
|
|
|
|
@tex
|
|
% I think something like @colophon should be in texinfo. In the
|
|
% meantime:
|
|
\long\def\colophon{\hbox to0pt{}\vfill
|
|
\centerline{The body of this manual is set in}
|
|
\centerline{\fontname\tenrm,}
|
|
\centerline{with headings in {\bf\fontname\tenbf}}
|
|
\centerline{and examples in {\tt\fontname\tentt}.}
|
|
\centerline{{\it\fontname\tenit\/} and}
|
|
\centerline{{\sl\fontname\tensl\/}}
|
|
\centerline{are used for emphasis.}\vfill}
|
|
\page\colophon
|
|
% Blame: pesch@cygnus.com, 28mar91.
|
|
@end tex
|
|
|
|
@contents
|
|
@bye
|