dbx.1

来自「<B>Digital的Unix操作系统VAX 4.2源码</B>」· 1 代码 · 共 1,043 行 · 第 1/3 页

.\" SCCSID: @(#)dbx.1	8.7	4/9/91
.TH dbx 1 VAX
.SH Name
dbx \- debugger
.SH Syntax
.B dbx
[\fB\-r\fR] [\fB\-i\fR] [\fB\-k\fR] [\fB\-I\fI dir\fR\|] 
[\fB\-c\fI file\fR] [\fIobjfile\fR\|[\fIcoredump\fR\|]\|]
.SH Description
.NXR "dbx debugger"
.NX R "program" "debugging"
.NX RS "symbolic debugger" "dbx debugger"
.NX RS "debugger" "dbx debugger"
.NX RA "adb debugger" "dbx debugger"
The
.PN dbx
debugger is a tool for source level debugging and execution
of programs running under the ULTRIX operating system. Once you invoke 
.PN dbx ,
you can issue 
.PN dbx
commands that control and trace program execution, print variable and
expression values, and display and edit source files.
.PP
You can use command options to modify some steps that
.PN dbx
performs during startup. (For information on the available options, see
Options.) Unless you specify the
.B \-r
option, 
.PN dbx
prompts you for a command before it begins executing your program. The 
.PN dbx
prompt appears as follows:
.EX
(dbx)
.EE
To leave 
.PN dbx
issue the 
.B quit 
command.
.SS Arguments
.PP 
On the command line, the \fIobjfile\fP
argument names the object file that you want
.PN dbx
to read as input. For complete
.PN dbx
support, the object file must contain extended symbol table
information. The supported compilers each have an option,
.B \-g ,
that produces the symbol table information in the object file.
.PP 
The extended symbol table contains information that makes your debugging
session more convenient.
For example, the extended symbol table contains the names of all
the source files translated by the compiler to create the object file.
This information allows you to look at all the source code that went
into creating an object file during your debugging session.
.PP 
If your object file does not contain the extended symbol table, use the 
commands described in Machine Level Commands
to debug your program.
.PP 
If you omit the 
.I objfile
argument, 
.PN dbx
prompts you for the name of an object file. If you press the Return key,
.PN dbx
attempts to read a file named 
.PN a.out
from the current directory. If no
.PN a.out
file exists, 
.PN dbx
issues another prompt to allow you to enter a file name. If you press
the Return key, 
.PN dbx 
exits.
.PP
The
.I coredump   
argument names a core dump file. You can examine the core dump file to determine
the state of your program. 
If you omit
.I coredump
and 
a core file exists in the current directory,
.PN dbx
reads in a file named
.PN core .
.SS Initialization File
.PP
During its startup, 
.PN dbx
reads and executes the commands in an initialization file, if one is
present. By default, 
.PN dbx
searches for the file
.PN \&.dbxinit
in the current directory.  If no
.PN \&.dbxinit
file exists in the current directory,
.PN dbx
searches your home directory for the file. You can use the
initialization file to automatically issue setup commands when
you begin a
.PN dbx
session.
.PP
You can rename the
.PN dbx
debugger. If you rename the debugger, you must also rename its
initialization file. The debugger expects the initialization file's name
to be a period (\.), followed by the first eight characters in the
debugger's name, followed by the string
.PN init .
For example, if you rename
.PN dbx
to
.PN srcdebugger ,
the debugger searches for an initialization file named
.PN .srcdebuginit .
.SH Options
.TP 
.BI \-c file
Executes the 
.PN dbx
commands in the specified file before
reading from standard input.
.TP
.B \-i
Forces
.PN dbx
to act as though standard input is a terminal.
.TP
.BI \-I dir
Adds the specified directory to the list of directories
that 
.PN dbx
searches for source files.
Normally,
.PN dbx
searches for source files in the current directory
and in the directory where \fIobjfile\fP is located.
You can also issue the
.PN use
command to set the directory search path.
.TP 
.B \-k
Maps memory addresses. This option is useful for kernel debugging.
.TP
.B \-r
Executes \fIobjfile\fP immediately.
If the program executes successfully,
.PN dbx
exits. If program execution terminates with an error, 
.PN dbx
displays the message that describes the error. You can then either invoke the 
debugger or let the program
continue exiting.
The
.PN dbx
debugger
reads from 
.PN /dev/tty 
when you specify the \fB\-r\fP option 
and standard input is not a terminal.
.SS Execution and Tracing Commands
Using
.PN dbx
commands, you can execute your program under control of the debugger.
You can trace its execution and control whether your program traps
certain signals. The following list describes the commands that allow
you to execute and trace your program:
.IP "\fBcall\fP \fIprocedure\fR[\fB(\fIparameters\fB)\fR]"
.NXR "call command (dbx)"
Executes the object code associated with the named procedure or function
and passes any parameters you specify to the procedure.
.IP "\fBcatch\fP \fIinteger\fP"
.ns
.IP "\fBcatch\fP \fIsignal-name\fP"
.ns
.IP "\fBignore\fP \fIinteger\fP"
.ns
.IP "\fBignore\fP \fIsignal-name\fP"
Starts or stops trapping a signal before it is sent
to the program.
.NXR "catch command (dbx)" 
.NXR "ignore command (dbx)"
These commands are useful when you are debugging a program 
that handles signals, such as interrupts.
.sp 1
You can specify a signal by number or by a name
(for example, SIGINT).
Signal names are case insensitive and the SIG prefix is optional.
By default, 
.PN dbx
traps all signals except SIGCONT, SIGCHILD,
SIGALRM, and SIGKILL.
.IP "\fBcont\fP \fR[\fIinteger\fR]"
.ns
.IP "\fBcont\fP \fR[\fIsignal-name\fR]"
Continues execution from where it stopped. 
If you specify a signal name or number, the process continues as though
.NXR "cont command (dbx)"
it received the signal.
If you omit the signal name or number, program execution continues as if a signal had
not been encountered. For information about signal names and numbers,
see
.MS signal 3 .
.IP ""
Execution cannot be continued if the process has 
called the standard exit procedure.
The
.PN dbx
debugger does not allow the process to exit, so you can examine
the program state.
.IP "\fBdelete\fP \fIcommand-number\fP \&.\&.\&."
.ns
.IP "\fBdelete all\fP"
.NXR "delete command (dbx)"
Removes the trace or stop event that corresponds to the specified number or
removes all traces and stops.
Trace and stop event numbers are assigned by
.PN dbx .
You can display them using the
.B status 
command.
.IP 
The command \fBdelete all\fP removes
all existing traces and stops at once. The command \fBdelete *\fP has
the same effect.
.IP "\fBnext\fP"
.NXR "next command (dbx)"
Executes to the next source line. If the source line that is executed
contains a call to a procedure or function, the
.B next 
command executes the entire procedure or function. Program execution
stops following the return from the procedure; that is, execution stops prior 
to the source line that follows the call.
.IP "\fBreread\fP"
Reads the object file before beginning program execution. The
debugger reads the object file directly before executing the program in
response to a
.B run
or 
.B rerun 
command. Reading the object file directly before executing the program
ensures that the execution is unaffected by any corruption that might have
occurred during a previous run.
.IP "\fBreturn\fP [\fIprocedure\fP]"
.NXR "return command (dbx)"
Executes until a return to \fIprocedure\fP is executed or
until the current procedure returns if none is specified.
.IP "\fBrun\fP [\fIargs\fP] [\fB<\fP \fIfilename\fP] [\fB>\fP \fIfilename\fP]"
.NXR "run command (dbx)"
.NXR "rerun command (dbx)"
.ns
.IP "\fBrerun\fP [\fIargs\fP] [\fB<\fP \fIfilename\fP] [\fB>\fP \fIfilename\fP]"
Starts executing \fIobjfile\fP, passing \fIargs\fP as command line arguments.
You can use angle brackets (\fB<\fP or \fB>\fP) to redirect input
or output in the usual manner.
If you issue the 
\fBrerun\fP 
command without any arguments, 
.PN dbx
passes the previous argument list to the program.  Otherwise,
the
.B rerun
command is identical to \fBrun\fP.
If you recompiled your program since the last time 
.PN dbx
read symbolic information, it reads in the new information.
.IP "\fBstatus\fP [\fB>\fP \fIfilename\fP]"
.NXR "status command (dbx)"
Displays the currently active trace and stop events.
.IP \fBstep\fP
.NXR "step command (dbx)"
Executes one source line. If the source line contains a call to a
procedure or function, the
.B step
command stops at the first line of the procedure or function.
.IP "\fBstop if\fP \fIcondition\fP"
.ns
.IP "\fBstop\fP \fBat\fP \fIsource-line-number\fP [\fBif\fP \fIcondition\fP]"
.ns
.IP "\fBstop\fP \fBin\fP \fIprocedure/function\fP [\fBif\fP \fIcondition\fP]"
.ns
.IP "\fBstop\fP \fIvariable\fP [\fBif\fP \fIcondition\fP]"
.NXR "stop command (dbx)"
Stops execution when the specified condition is true, the specified line
number is reached, the specified procedure or function is called, or the
specified variable changes value.
.IP
If you specify a condition with the \fIsource-line-number\fP,
\fIprocedure/function\fP, or \fIvariable\fP argument, execution
stops only when the condition is true. For example, suppose you specified
that execution should stop at line 14 if variable \fIa\fP is greater in value than
variable \fIb\fP. The debugger continues execution if variable \fIa\fP 
equals variable \fIb\fP when it reaches line 14.
.IP "\fBtrace\fP [\fBin\fP \fIprocedure/function\fP] [\fBif\fP \fIcondition\fP]"
.ns
.IP "\fBtrace\fP \fIsource-line-number\fP [\fBif\fP \fIcondition\fP]"
.ns
.IP "\fBtrace\fP \fIprocedure/function\fP [\fBin\fP \fIprocedure/function\fP] [\fBif\fP \fIcondition\fP]"
.ns
.IP "\fBtrace\fP \fIexpression\fP \fBat\fP \fIsource-line-number\fP [\fBif\fP \fIcondition\fP]"
.ns
.IP "\fBtrace\fP \fIvariable\fP [\fBin\fP \fIprocedure/function\fP] [\fBif\fP \fIcondition\fP]"
.NXR "trace command (dbx)"
Displays tracing information during program execution.  The
.PN dbx
debugger associates a number with the source line that contains the
trace. You use the number to turn off tracing, as described with the
.B delete
command.
.IP
The first argument to the
.B trace
command describes what is to be traced. You can specify a procedure or
function name, a source line number, an expression, or a variable name.
.IP 
Specifying a procedure or function name 
causes 
.PN dbx
to display the name of the calling routine, the
source line that contains the call, and the parameters
that are passed to the called routine.  
In addition, 
.PN dbx 
notes the return of the named procedure or function and displays the return value,
if any.
The debugger displays this information each time
the procedure or function is called.
.IP
If you specify the \fBin\fP \fIprocedure/function\fP clause,
.PN dbx
displays tracing information 
only while executing the specified procedure or function.
.IP 
If you specify \fIsource-line-number\fP, 
.PN dbx
displays the source line immediately prior to executing it.
You can specify a source line number in a source file that is not the current
one. To do so, precede the source line number with the source file name in