Appendix A. dbx Commands
Prev |  | Next

## Appendix A. `dbx` Commands

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 [ ... ] |  | Adds the process IDs specified to the group list. Only processes in the process pool can be added to the group list.
`addproc` pid [ ... ] |  | Adds the specified process(es) to the pool of `dbx` controlled processes.
``address ```/` count format |  | Prints the contents of the specified address or disassembles the code for the machine instruction at the specified address. Repeats for a total of count addresses in increasing address—in other words, an `examine forward` command. The format codes are listed in Table 7-2.
address ```?` count format |  | Prints the contents of the specified address or disassembles the code for the machine instruction at the specified address. Repeats for a total of count addresses in decreasing address—in other words, an “examine backward” command. The format codes are listed in Table 7-2.
address `````/` count `L` value mask |  | Examines count 32-bit words in increasing address and print those 32-bit words which, when ORed with mask, equal value. This command searches memory for specific patterns.
`alias` |  | Lists all existing aliases.
`alias` name |  | Lists the alias definition for name.
`alias` name command |  | Defines name as an alias for command.
`alias` name “string” |  | Defines name as an alias for string. With this form of the `alias` command, you can provide command arguments in the alias definition.
`alias` name`(`arg1 [`,` ... argN]`)` “string” |  | Defines name as an alias for string. arg1 through argN are arguments to the alias, appearing in the string definition. When you use the alias, you must provide values for the arguments, which `dbx` then substitutes in string.
`assign` register `=` expression |  | Assigns the value of expression to register. You must precede the name of the register with a dollar sign ($).
`assign` variable `=` expression |  | Assigns the value of expression to the program variable, variable.
`catch` |  | Prints a list of all signals caught.
`catch` { `signal` | `all`} |  | Instructs `dbx` to stop your program whenever it receives the specified signal. If you use the keyword `all` rather than giving a specific signal, `dbx` catches all signals.
`ccall` func`(`arg1, arg2, ... , argn`)` |  | Calls a function with the given arguments.
`clearcalls` |  | Clears all stopped interactive calls.
`cont` |  | Continues execution with the current line.
`cont` {`at` | `to`} `line` |  | Sets a temporary breakpoint at the specified source line, then resumes execution with the current line. When your program reaches the breakpoint at `line`, `dbx` stops your program and deletes the temporary breakpoint. The keywords `at` and `to` are equivalent.
`cont` `in` `procedure` |  | Sets a temporary breakpoint to stop execution upon entering the specified procedure, then resumes execution with the current line. When your program reaches the breakpoint in `procedure`, `dbx` stops your program and deletes the temporary breakpoint.
`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` |  | Sets a temporary breakpoint at the specified source line, then resumes 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`] `in` `procedure` |  | Sets a temporary breakpoint to stop execution upon entering the specified procedure, then resumes 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.
`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` |  | Sets a temporary breakpoint at the specified address, then resumes execution with the current machine instruction. When your program reaches the breakpoint at `address`, `dbx` stops your program and deletes the temporary breakpoint. 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` |  | Sets a temporary breakpoint to stop execution upon entering the specified procedure, then resumes execution with the current machine instruction. When your program reaches the breakpoint in `procedure`, `dbx` stops your program and deletes the temporary breakpoint. 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`} |  | Deletes the item(s) specified. If you use the keyword `all` instead of listing individual items, `dbx` deletes all breakpoints, traces, and conditional commands.
`delpgrp` pid [ ... ] |  | Deletes the process IDs specified from the group list.
`delproc` pid [ ... ] |  | Deletes the specified process(es) from the pool of `dbx` controlled processes.
`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` ... ] |  | Disables the item(s) listed. The specified breakpoint(s), trace(s), or conditional command(s) no longer affect program execution. This command has no effect if the item you specify is already disabled.
`down` [num] |  | Moves down the specified number of activation levels in the stack. The default is one level.
`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] |  | Edits a file. If you set the `dbx` variable $editor to the name of an editor, the `edit` command invokes that editor on the source file. If you do not set the `dbx` variable $editor, `dbx` checks whether you have set the environment variable EDITOR and, if so, invokes that editor. If you do not set either the `dbx` variable or the environment variable, `dbx` invokes the `vi` editor. When you exit the editor, you return to the `dbx` prompt. 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.
`edit` `pid` pid |  | Edits the process ID pid clause.
`enable` `item` [, `item` ... ] |  | Enables the item(s) specified. This command activates the specified breakpoint(s), trace(s), or conditional command(s), reversing the effects of a `disable` command, so that they affect program execution.
`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} |  | Changes the current activation level. If you specify an activation level by number, `dbx` changes to that activation level. If you specify `procedure`, `dbx` changes to the activation level of that procedure. If you specify a procedure name and that procedure has called itself recursively, `dbx` changes to the most recently called instance of that procedure. If you specify `procedure`, `dbx` changes the current source file to be that procedure, even if the procedure is not active.
`givenfile` [file] |  | If you provide a filename, `dbx` kills the currently running processes and loads the executable code and debugging information found in file. If you do not provide a filename, `dbx` displays the name of the program that it is currently debugging.
`goto` `line` |  | Begins execution at the specified line. You may not use the `goto` command to resume execution with a line outside of the current procedure.
`hed` |  | Edits only the last line of the history list (the last command executed).
`hed` num1 |  | Edits line num1 in the history list.
`hed` num1`,`num2 |  | Edits the lines in the history list from num1 to num2.
`hed all` |  | Edits the entire history list.
`help` |  | Shows the list of available help sections.
`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` |  | Prints a list of all signals ignored.
`ignore` { `signal` | `all`} |  | Instructs `dbx` to ignore the specified signal. All ignored signals are passed to your program normally. If you use the keyword `all` rather than giving a specific signal, `dbx` ignores all signals.
`kill` |  | Kills the active process.
`kill` pid ... |  | Kills the active process(es) whose PIDs are specified.
`list` |  | Lists $listwindow lines beginning at the current line.
`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 |  | Lists $listwindow lines starting at procedure func.
`list` func`:`exp |  | Lists exp2 lines, beginning at func.
`list` func`,`exp |  | Lists all source between func and exp, inclusive.
`listobj` |  | Lists dynamic shared objects being used. The base application is first in the list.
`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.
`playback input` [file] |  | Executes the commands from file. The default file is the current temporary file created for the `record input` command. If the `dbx` variable $pimode is nonzero, the commands are printed out as they are played back.
`playback output` [file] |  | Prints the commands from file. The default file is the current temporary file created for the `record output` command.
`print` [exp1 [`,` exp2`,` ... ] ] |  | Prints the value(s) of the specified expression(s).
`printd` [exp1 [`,` exp2`,` ... ] ] |  | Prints the value(s) of the specified expression(s) in decimal.
`printf` string [`,` exp1 [`,` exp2`,` ... ] ] |  | Prints the value(s) of the specified expression(s) in the format specified by the string, string. The `printf` command supports all formats except “%s”. For a list of formats, see the `printf`(3S) reference page.
`printo` [exp1 [`,` exp2`,` ... ] ] |  | Prints the value(s) of the specified expression(s) in octal.
`printregs` |  | Prints all register values.
`printx` [exp1 [`,` exp2`,` ... ] ] |  | Prints the value(s) of the specified expression(s) in hexadecimal.
`quit` |  | Quits `dbx`.
`record` |  | Displays the current input and output recording sessions.
`record input` [file] |  | Records everything you type to `dbx` in file. The default file is a temporary `dbx` file in the `/tmp` directory. The name of the temporary file is stored in the `dbx` variable $defaultin.
`record output` [file] |  | Records all `dbx` output in file. The default file is a temporary `dbx` file in the `/tmp` directory. The name of the temporary file is stored in the `dbx` variable $defaultout. If the `dbx` variable $rimode is nonzero, `dbx` also records the commands you enter.
`rerun` `run-arguments` |  | Without any arguments, repeats the last `run` command, if applicable. Otherwise, `rerun` is equivalent to the `run` command without any 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 |  | Starts your program and passes to it any arguments that you provide. All shell processing is accepted, such as unglobbing of * and ? in filenames. Redirection of the program's standard input and standard output, and/or standard error is also done by the shell. In other words, the `run` command does exactly what typing `target` `run-arguments` does. You can specify a target, either on `dbx` invocation or in a prior `givenfile` command. `dbx` passes ./target as `argv[0]` to target when you specify it as a relative pathname. You can specify target either on `dbx` invocation or in a prior `givenfile` command. `dbx` passes ./target as `argv[0]` to target when you specify it as a relative pathname. 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` |  | Displays a list of predefined and user defined variables.
`set` var `=` exp |  | Defines (or redefines) the specified `dbx` variable, setting its value to that of the expression you provide.
`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` |  | Shows the group process list and the group history.
`showproc` [pid | `all`] |  | Shows processes already in the `dbx` process pool or processes that `dbx` can control. If you provide no arguments, `dbx` lists the processes it already controls. If you provide a pid, `dbx` displays the status of the specified process. If you use argument “all,” `dbx` lists all the processes it controls as well as all those processes it could control but that are not yet added to the process pool.
`source` [file] |  | Executes `dbx` commands from file.
`status` |  | Displays all breakpoints, traces, and conditional commands.
`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` |  | Set a breakpoint at the current source line.
`stop at` `line` |  | Sets a breakpoint at the specified source line.
`stop` `expression` |  | Inspects the expression. If the expression is type pointer, checks the data being pointed at. Otherwise, checks the 32 bits at the address given by the expression.
`stop` `in` `procedure` |  | Sets a breakpoint to stop execution upon entering the specified procedure.
`stop` [`expression`| `variable`] |  | Inspects the value before executing each source 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).
`stop` [`expression`| `variable`] `at` `line` |  | Inspects the value at the given source line. Stops if the value has changed. 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` [`expression`| `variable`] `in` `procedure` |  | Inspects the value at every source line within a given procedure. Stops if the value has changed. 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` |  | Evaluates the expression before executing each source line. Stops if the expression is true.
`stop` `at` `line` `if` `expression` |  | Evaluates the expression at the given source line. Stops if the expression is true.
`stop` `in` `procedure` `if` `expression` |  | Evaluates the expression at every source line within a given procedure. Stops if the expression is true.
`stop` [`expression1`| `variable`] `if` `expression` `2` |  | Tests both conditions before executing each source line. Stops if both conditions are true. 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` |  | Tests both conditions at the given source line. Stops if both conditions are true. 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` |  | Tests both conditions at every source line within a given procedure. Stops if both conditions are true. 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` |  | Sets an unconditional breakpoint at the specified address (for machine-level debugging).
`stopi` `in` `procedure` |  | Sets an unconditional breakpoint to stop execution upon entering the specified procedure (for machine-level debugging).
`stopi` [`expression`| `variable`] |  | Inspects the value before executing each machine instruction and stops if the value has changed. 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` |  | Inspects the value when the program is at the given address and stops if the value has changed (for machine-level debugging). 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` |  | Inspects the value at every machine instruction within a given procedure and stops if the value has changed. 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` |  | Evaluates the expression before executing each machine instruction and stops if the expression is true.
`stopi` `at` `address` `if` `expression` |  | Evaluates the expression at the given address and stops if the expression is true (for machine-level debugging).
`stopi` `in` `procedure` `if` `expression` |  | Evaluates the expression at every machine instruction within a given procedure and stops if the expression is true.
`stopi` [`expression1`| `variable`] `if` `expression2` |  | Tests both conditions before executing each machine instruction. Stops if both conditions are true. 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` |  | Tests both conditions at the given address (for machine-level debugging). Stops if both conditions are true. 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` |  | Tests the expression each time that the given variable changes within the given procedure. 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 |  | Suspends all the processes in pgrp.
`suspend pid` pid |  | Suspends the process pid if it is in the `dbx` process pool. If it is not running, this command does nothing.
`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`}] |  | Prints a list of all system calls caught upon entry ( `call`) or return ( `return`). If you provide neither the `call` nor `return` keyword, `dbx` lists all system calls that are caught.
`syscall ignore` [{`call` | `return`}] |  | Prints a list of all system calls not caught upon entry ( `call`) or return ( `return`). If you provide neither the `call` nor `return` keyword, `dbx` lists all system calls that are ignored.
`syscall catch` {`call` | `return`} { `system_call` | `all`} |  | Sets a breakpoint to stop execution upon entering ( `call`) or returning from ( `return`) the specified system call. Note that you can set `dbx` to catch both the call and the return of a system call. 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`} |  | Clears the breakpoint to stop execution upon entering ( `call`) or returning from ( `return`) the specified system call. 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` |  | Whenever your program reaches the specified line, `dbx` prints the value of the variable if its value has changed. 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` |  | Whenever the variable changes within the procedure, `dbx` prints the old and new values of that 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).
`trace` [`expression1`| `variable`] `at` `line` `if` `expression2` |  | Prints the value of the variable (if changed) whenever your program reaches the specified line and the given expression is true. 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` |  | Whenever the variable changes within the procedure that you specify, `dbx` prints the old and new values of that variable, if the given expression is true. 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`] |  | Whenever the specified variable changes, `dbx` prints the old and new values of that variable. (For machine-level debugging.) 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` |  | This command is equivalent to entering `trace` `procedure`. (For machine-level debugging.)
`tracei` [`expression`| `variable`] `at` `address` |  | Prints the value of the variable whenever your program reaches the specified address. (For machine-level debugging.) 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` |  | Whenever the variable changes within the procedure that you specify, `dbx` prints the old and new values of that variable. (For machine-level debugging.) 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` |  | Prints the value of the variable whenever your program reaches the specified address and the given expression is true. (For machine-level debugging.) 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` |  | Whenever the variable changes within the procedure that you specify, `dbx` prints the old and new values of that variable, if the given expression is true. (For machine-level debugging.) 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 |  | Removes the specified alias.
`unrecord` session1 [`,` session2 ... ] |  | Turns off the specified recording session(s) and closes the file(s) involved.
`unrecord all` |  | Turns off all recording sessions and closes all files involved.
`unset` var |  | Removes the specified `dbx` 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` |  | Waits for the active process to stop for an event.
`wait pid` pid |  | Waits for the process pid to stop for an event.
`waitall` |  | Waits for any process currently running to breakpoint or stop for any reason.
`whatis` variable |  | Prints the type declaration for the specified variable or procedure.
`when` [`expression`| `variable`] `{` `command-list``}` |  | Inspects the value before executing each source line. If it has changed, executes the 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``}` |  | Inspects the value at the given source line. If it has changed, executes the 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``}` |  | Inspects the value at every source line within a given procedure. If it has changed, executes the 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``}` |  | Evaluates the expression before executing each source line. If it is true, executes the command list.
`when` `at` `line` `if` `expression` `{` `command-list``}` |  | Evaluates the expression at the given source line. If it is true, executes the command list.
`when` `in` `procedure` `if` `expression` `{` `command-list``}` |  | Evaluates the expression at every source line within a given procedure. If it is true, executes the command list.
`when` [`expression1`| `variable`] `if` `expression2` `{` `command-list``}` |  | Checks if the value of the variable has changed. If it has changed and the expression is true, executes the command list. 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).
`when` [`expression1`| `variable`] `at` `line` `if` `expression2` `{` `command-list``}` |  | Checks if the value of the variable has changed each time the line is executed. If the value has changed and the expression is true, executes the command list. 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).
`when` [`expression1`| `variable`] `in` `procedure` `if` `expression2` `{` `command-list``}` |  | Checks if the value of variable has changed at each source line of the given procedure. If the value has changed and the expression is true, executes the command list. 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).
`wheni if` expression `{`command-list`}` |  | Evaluates the expression before executing each machine instruction. If the expression is true, executes the command list.
`wheni at` address `if` expression `{`command-list`}` |  | Evaluates the expression at the given address. If the expression is true, executes the command list. (For machine-level debugging.)
`wheni in` procedure `if` expression `{`command-list`}` |  | Evaluates the expression in the given procedure. If the expression is true, executes the command list. (For machine-level debugging.)
`wheni` variable `at` address `if` expression `{`command-list`}` |  | Tests both conditions at the given address. If the conditions are true, executes the command list. (For machine-level debugging.) 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).
`wheni` variable `in` procedure `if` expression `{`command-list`}` |  | Tests both conditions at every machine instruction within a given procedure. If they are true, executes the command list.
`where` |  | Print a stack trace.
`which` variable |  | Prints the fully qualified name of the active version of the specified variable.
`whichobj` variable |  | Lists the dynamic shared objects that contain the named variable.

Prev | Table of Contents | Next
Chapter 8. Multiple Process Debugging |  | Appendix B. Predefined Aliases