All dbx commands are listed below along with a brief description. For more information about a command, refer to its description in the main text of this guide.
; | Use the semicolon (;) as a separator to include multiple commands on the same command line. | |
\ | Use the backslash (\) at the end of a line of input to dbx to indicate that the command is continued on the next line. | |
./ | Repeats the previous examine command by incrementing the address. | |
/[reg_exp] | Searches forward through the current source file from the current line for the regular expression reg_exp. If dbx reaches the end of the file without finding the regular expression, it wraps around to the beginning of the file. dbx prints the first source line containing a match of the search expression. If you do not supply reg_exp, dbx searches forward, based on the last regular expression you searched for. | |
.? | Repeats the previous examine command by decrementing the address. | |
?[reg_exp] | Searches backward through the current source file from the current line for the regular expression reg_exp. If dbx reaches the beginning of the file without finding the regular expression, it wraps around to the end of the file. dbx prints the first source line containing a match of the search expression. If you do not supply a regular expression, dbx searches backward, based on the last regular expression you searched for. | |
!! | Repeats the previous command. If the value of the dbx variable $repeatmode is set to 1, then entering a carriage return at an empty line is equivalent to executing !!. By default, $repeatmode is set to 0. | |
!string | Repeats the most recent command that starts with the specified string. | |
!integer | Repeats the command associated with the specified integer in the history list. | |
!-integer | Repeats the command that occurred integer times before the most recent command. Entering !-1 executes the previous command, !-2 the command before that, and so forth. | |
active [pid] | Selects a process, pid, from dbx process pool as the active process. If you do not provide a process ID, dbx prints the currently active process ID. | |
addpgrp pid [ ... ] |
| |
addproc pid [ ... ] |
| |
address / count format |
| |
address ? count format |
| |
address / count L value mask |
| |
alias | ||
alias name | ||
alias name command | ||
alias name "string" |
| |
alias name(arg1 [, ... argN]) "string" |
| |
assign register = expression |
| |
assign variable = expression |
| |
catch | ||
catch {signal | all} |
| |
ccall func(arg1, arg2, ... , argn) | ||
clearcalls | ||
cont | Continues execution with the current line. | |
cont {at | to} line |
| |
cont in procedure |
| |
cont [signal] | Continues execution with the current line and sends the specified signal to your program. If you do not provide a signal, but your program stopped because dbx caught a signal intended for your program, then dbx sends that signal to your program when you continue execution. | |
cont [signal] {at | to} line |
| |
cont [signal] in procedure |
| |
conti [signal] | Continues execution with the current machine instruction. If you specify a signal, dbx sends the signal to your program. If you do not provide a signal, but your program stopped because dbx caught a signal intended for your program, then dbx sends that signal to your program when you continue execution. | |
conti [signal] {at | to} address |
If you specify a signal, then dbx sends the signal to your program. If you do not provide a signal, but your program stopped because dbx caught a signal intended for your program, then dbx sends that signal to your program when you continue execution. | |
conti [signal] in procedure |
If you specify a signal, then dbx sends the signal to your program. If you do not provide a signal, but your program stopped because dbx caught a signal intended for your program, then dbx sends that signal to your program when you continue execution. | |
corefile [file] | If you provide a filename, dbx uses the program data stored in the core dump file. If you do not provide a filename, dbx displays the name of the current core file. | |
delete {item [, item ...] | all} |
| |
delpgrp pid [ ... ] | ||
delproc pid [ ... ] |
| |
dir [dir ...] | If you provide one or more directories, dbx adds those directories to the end of the source directory list. If you do not provide any directories, dbx displays the current source directory list. | |
disable item [, item ... ] |
| |
down [num] | Moves down the specified number of activation levels in the stack. The default is one level. | |
duel | Invokes duel, the high-level debugging tool. | |
duel alias | Shows are current duel aliases. | |
duel clear | Deletes all duel aliases. | |
dump | Prints information about the variables in the current procedure. | |
dump procedure | Prints information about the variables in the specified procedure. The procedure must be active. | |
dump . | Prints information about the variables in all procedures currently active. | |
edit [file | procedure] |
If you supply a filename, edit invokes the editor on that file. If you supply the name of a procedure, edit invokes the editor on the file that contains the source for that procedure. If you do not supply a filename or a procedure name, edit invokes the editor on the current source file. | |
editpid pid | ||
enable item [, item ... ] |
| |
file [file] | Changes the current source file to file. The new file becomes the current source file, on which you can search, list, and perform other operations. | |
func | Displays the name of the procedure corresponding to the current activation level. | |
func {activation_level | procedure} |
| |
givenfile [file] |
If you do not provide a filename, dbx displays the name of the program that it is currently debugging. | |
hed | Edits only the last line of the history list (the last command executed). | |
hed num1 | ||
hed num1,num2 | ||
hed all | ||
help | ||
help all | Displays the entire dbx help file. dbx displays the file using the command name given by the dbx$pager variable. The dbx help file is large and can be difficult to use if you use a simple paging program like more(1). A useful technique is to set the $pager variable to a text editor like vi(1). | |
help help | Explains how to display the help file in your favorite editor. | |
help section | Shows this help section. dbx displays the file using the command name given by the dbx$pager variable. (By default, it uses more.) A useful technique is to set the $pager variable to a text editor like vi(1). | |
history | Prints the commands in the history list. | |
ignore | ||
intercept {all | item} |
| |
intercept unexpected {[all] | [item [, item] ]} |
| |
intercept ... if expression |
| |
ignore {signal | all} |
| |
kill | ||
kill pid ... | ||
list exp | Lists $listwindow lines starting with the line number given by the expression exp. The expression may be any valid expression that evaluates to an integer value. | |
list exp1:exp2 | Lists exp2 lines, beginning at line exp1. | |
list exp1,exp2 | Lists all source between line exp1 and line exp2 inclusive. | |
list func | ||
list func:exp | Lists exp2 lines, beginning at func. | |
list func,exp | Lists all source between func and exp, inclusive. | |
listclones | Lists all the root functions and their derived clones. | |
listclones func |
| |
listinlines | Lists all of the inlined routines with their start and end addresses. | |
listinlines func |
| |
listobj | Lists dynamic shared objects being used. The base application is first in the list. | |
listregions | Lists all the memory regions being used by the application. Any object region with debugging information is marked with a "Y." | |
next [n] | Executes the specified number of lines of source code, stepping over procedures. If you do not provide an argument, next executes one line. If next encounters any breakpoints, even in procedures that it steps over, it immediately stops execution. | |
nexti [n] | Executes the specified number of machine instructions, stepping over procedures. If you do not provide an argument, nexti executes one line. If nexti encounters any breakpoints, even in procedures which it steps over, it immediately stops execution. | |
pixie clear | Clears the basic block counts for the current execution. | |
pixie write | Writes the counts file with the current basic block counts. The counts reflect the exectuion of the program since the run command or since the last pixie clear command, whichever is more recent. | |
playback input [file] |
| |
playback output [file] |
| |
print [exp1 [, exp2, ... ] ] | ||
printd [exp1 [, exp2, ... ] ] |
| |
printenv | Prints the list of environment variables affecting the program being debugged. | |
printf string [, exp1 [, exp2, ... ] ] |
| |
printo [exp1 [, exp2, ... ] ] |
| |
printregs | ||
printx [exp1 [, exp2, ... ] ] |
| |
quit | ||
record | ||
record input [file] |
| |
record output [file] |
| |
rerun run-arguments |
| |
resume | Resumes execution of the program, and returns immediately to the dbx command interpreter. | |
resume [signal] | Resumes execution of the process, sending it the specified signal, and returns immediately to the dbx command interpreter. | |
return | Continues execution until control returns to the next procedure on the stack. | |
return proc | Continues execution until control returns to the named procedure. | |
run run-arguments |
A run command must appear on a line by itself and cannot be followed by another dbx command. Terminate the command line with a return (new-line). Note that you cannot include a run command in the command list of a when command. | |
set | ||
set var = exp | Defines (or redefines) the specified dbx variable, setting its value to that of the expression you provide. | |
setenv | Prints the list of environment variables for the program being debugged. | |
setenv VAR | Sets the environment variable VAR to an empty value. | |
setenv VAR value |
| |
setenv VAR $var |
| |
setenv VAR "charstring" |
| |
sh | Invokes a subshell. To return to dbx from the subshell, enter exit at the command line, or otherwise terminate the subshell. | |
sh com | Executes the specified shell command. dbx interprets the remainder of the line as a command to pass to the spawned shell process, unless you enclose the command in double-quotes or you terminate your shell command with a semicolon (;). | |
showpgrp | ||
showproc [pid | all] |
| |
showthread [full] | Prints brief status information about the current thread. If the full qualifier is included, prints full status information. | |
showthread [full] [thread] {number | $no | all} |
| |
source [file] | Executes dbx commands from file. | |
status | ||
step [n] | Executes the specified number of lines of source code, stepping into procedures. If you do not provide an argument, step executes one line. If step encounters any breakpoints, it immediately stops execution. | |
stepi | Single steps one machine instruction, stepping into procedures (as called by jal and jalr). If stepi encounters any breakpoints, it immediately stops execution. | |
stepi [n] | Executes the specified number of machine instructions, stepping into procedures (as called by jal and jalr). | |
stop at | ||
stop at line | Sets a breakpoint at the specified source line. | |
stop expression |
| |
stop in procedure |
| |
stop [expression|variable] |
| |
stop [expression|variable] at line |
| |
stop [expression|variable] in procedure |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stop if expression |
| |
stop at line if expression |
| |
stop in procedure if expression |
| |
stop [expression1|variable] if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stop [expression1|variable] at line if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stop [expression1|variable] in procedure if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stopi at | Sets an unconditional breakpoint at the current machine instruction. | |
stopi at address |
| |
stopi in procedure |
| |
stopi [expression|variable] |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stopi [expression|variable] at address |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stopi [expression|variable] in procedure |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stopi if expression |
| |
stopi at address if expression |
| |
stopi in procedure if expression |
| |
stopi [expression1|variable] if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stopi [expression1|variable] at address if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
stopi [expression1|variable] in procedure if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
suspend | Suspends the active process if it is running. If it is not running, this command does nothing. If you use the keyword all, suspends all active processes. | |
suspend pgrp | ||
suspend pid pid |
| |
syscall | Prints a summary of the catch and ignore status of all system calls. The summary is divided into four sections: 1) caught at call, 2) caught at return, 3) ignored at call, and 4) ignored at return. | |
syscall catch [{call | return}] |
| |
syscall ignore [{call | return}] |
| |
syscall catch {call | return} {system_call | all} |
If you use the keyword all rather than giving a specific system call, dbx catches all system calls. | |
syscall ignore {call | return} {system_call | all} |
If you use the keyword all rather than giving a specific system call, dbx clears the breakpoints to stop execution upon entering (call) or returning from (return) all system calls. | |
tag procedure | Searches the tag file for the given procedure. | |
trace variable | Whenever the specified variable changes, dbx prints the old and new values of that variable. | |
trace procedure | Prints the values of the parameters passed to the specified procedure whenever your program calls it. Upon return, dbx prints the return value. | |
trace [expression|variable] at line |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
trace [expression|variable] in procedure |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
trace [expression1|variable] at line if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
trace [expression1|variable] in procedure if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
tracei [expression|variable] |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
tracei procedure |
| |
tracei [expression|variable] at address |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
tracei [expression|variable] in procedure |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
tracei [expression1|variable] at address if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
tracei [expression1|variable] in procedure if expression2 |
If expression1 is of type pointer, look at the data pointed to and watch until it changes. If expression1 is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
unalias alias | ||
unrecord session1 [, session2 ... ] |
| |
unrecord all | Turns off all recording sessions and closes all files involved. | |
unset var | ||
unsetenv VAR | Removes the specified environment variable. | |
up [num] | Moves up the specified number of activation levels in the stack. The default is one level. | |
use [dir ...] | If you provide one or more directories, dbx replaces the source directory list with the directories that you provide. If you do not provide any directories, dbx displays the current source directory list. | |
wait | ||
wait pid pid | ||
waitall | Waits for any process currently running to breakpoint or stop for any reason. | |
whatis name | ||
when [expression|variable] {command-list} |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
when [expression|variable] at line {command-list} |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
when [expression|variable] in procedure {command-list} |
If the expression is of type pointer, look at the data pointed to and watch until it changes. If the expression is not of type pointer, look at the 32 bits at that address (assume the expression evaluates to an address). | |
when if expression {command-list} |
| |
when at line if expression {command-list} |
| |
when in procedure if expression {command-list} |
| |
when [expression1|variable] if expression2 {command-list} |
| |
when [expression1|variable] at line if expression2 {command-list} |
| |
when [expression1|variable] in procedure if expression2 {command-list} |
| |
wheni if expression {command-list} |
| |
wheni at address if expression {command-list} |
| |
wheni in procedure if expression {command-list} |
| |
wheni variable at address if expression {command-list} |
| |
wheni variable in procedure if expression {command-list} |
| |
where | ||
whereis name | Prints the fully qualified names of all versions of name. The range of objects examined is determined by $whereisdsolimit. | |
which name | Prints the fully qualified name of the active version of name. | |
whichobj variable |
|