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.

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.

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.

Repeats the most recent command that starts with the specified string.

Repeats the command associated with the specified integer in the history list.

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.

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.

Adds the process IDs specified to the group list. Only processes in the process pool can be added to the group list.

Adds the specified process(es) to the pool of dbx controlled processes.

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.

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.

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.

Lists all existing aliases.

Lists the alias definition for name.

Defines name as an alias for command.

Defines name as an alias for string. With this form of the alias command, you can provide command arguments in the alias definition.

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.

Assigns the value of expression to register. You must precede the name of the register with a dollar sign ($).

Assigns the value of expression to the program variable, variable.

Prints a list of all signals caught.

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.

Calls a function with the given arguments.

Clears all stopped interactive calls.

Continues execution with the current 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.

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.

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.

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.

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.

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.

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.

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.

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.

Deletes the item(s) specified. If you use the keyword all instead of listing individual items, dbx deletes all breakpoints, traces, and conditional commands.

Deletes the process IDs specified from the group list.

Deletes the specified process(es) from the pool of dbx controlled processes.

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.

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.

Moves down the specified number of activation levels in the stack. The default is one level.

Invokes duel, the high-level debugging tool.

Shows are current duel aliases.

Deletes all duel aliases.

Prints information about the variables in the current procedure.

Prints information about the variables in the specified procedure. The procedure must be active.

Prints information about the variables in all procedures currently active.

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.

Edits the process ID pid clause.

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.

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.

Displays the name of the procedure corresponding to the current activation level.

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.

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.

Edits only the last line of the history list (the last command executed).

Edits line num1 in the history list.

Edits the lines in the history list from num1 to num2.

Edits the entire history list.

Shows the list of available help sections.

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).

Explains how to display the help file in your favorite editor.

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).

Prints the commands in the history list.

Prints a list of all signals ignored.

Stops on all C++ exceptions, or exceptions that throw the base type item.

Stops on all C++ exceptions that have either no handler or are caught by an "unexpected" handler. You may omit all. If you specify item, stops on exceptions that throw the base type item.

You can append the if clause to all intercept commands. Your program stops only if expression is non-zero. Note that the context for evaluation of expression is the C++ runtime library, not that of the throw, so use global variables or fully qualified names in expression.

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.

Kills the active process.

Kills the active process(es) whose PIDs are specified.

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.

Lists exp2 lines, beginning at line exp1.

Lists all source between line exp1 and line exp2 inclusive.

Lists $listwindow lines starting at procedure func.

Lists exp2 lines, beginning at func.

Lists all source between func and exp, inclusive.

Lists all the root functions and their derived clones.

Lists the root and all derived clones for func.

Lists all of the inlined routines with their start and end addresses.

Lists all of the inlined versions of func with their start and end addresses.

Lists dynamic shared objects being used. The base application is first in the list.

Lists all the memory regions being used by the application. Any object region with debugging information is marked with a "Y."

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.

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.

Clears the basic block counts for the current execution.

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.

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.

Prints the commands from file. The default file is the current temporary file created for the record output command.

Prints the value(s) of the specified expression(s).

Prints the value(s) of the specified expression(s) in decimal.

Prints the list of environment variables affecting the program being debugged.

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.

Prints the value(s) of the specified expression(s) in octal.

Prints all register values.

Prints the value(s) of the specified expression(s) in hexadecimal.

Quits dbx.

Displays the current input and output recording sessions.

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.

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.

Without any arguments, repeats the last run command, if applicable. Otherwise, rerun is equivalent to the run command without any arguments.

Resumes execution of the program, and returns immediately to the dbx command interpreter.

Resumes execution of the process, sending it the specified signal, and returns immediately to the dbx command interpreter.

Continues execution until control returns to the next procedure on the stack.

Continues execution until control returns to the named procedure.

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.

Displays a list of predefined and user defined variables.

Defines (or redefines) the specified dbx variable, setting its value to that of the expression you provide.

Prints the list of environment variables for the program being debugged.

Sets the environment variable VAR to an empty value.

Sets the environment variable VAR to value, where value is not a dbx variable.

Sets the environment variable VAR to $var, where $var is a dbx variable.

Sets the environment variable VAR to charstring.

Invokes a subshell. To return to dbx from the subshell, enter exit at the command line, or otherwise terminate the subshell.

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 (;).

Shows the group process list and the group history.

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.

Prints brief status information about the current thread. If the full qualifier is included, prints full status information.

Prints brief status information about the thread identified by number or the value of $no, or all threads associated with the debug session. If the full qualifier is included, prints full status information. The thread qualifier does not affect the output, but it is allowed so the syntax can be the same as that for other commands that use the thread clause.

Executes dbx commands from file.

Displays all breakpoints, traces, and conditional commands.

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.

Single steps one machine instruction, stepping into procedures (as called by jal and jalr). If stepi encounters any breakpoints, it immediately stops execution.

Executes the specified number of machine instructions, stepping into procedures (as called by jal and jalr).

Set a breakpoint at the current source line.

Sets a breakpoint at the specified source line.

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.

Sets a breakpoint to stop execution upon entering the specified procedure. Execution will stop in all inlined or cloned instances of the procedure.

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).

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).

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).

Evaluates the expression before executing each source line. Stops if the expression is true.

Evaluates the expression at the given source line. Stops if the expression is true.

Evaluates the expression at every source line within a given procedure. Stops if the expression is true.

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).

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).

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).

Sets an unconditional breakpoint at the current machine instruction.

Sets an unconditional breakpoint at the specified address (for machine-level debugging).

Sets an unconditional breakpoint to stop execution upon entering the specified procedure (for machine-level debugging).

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).

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).

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).

Evaluates the expression before executing each machine instruction and stops if the expression is true.

Evaluates the expression at the given address and stops if the expression is true (for machine-level debugging).

Evaluates the expression at every machine instruction within a given procedure and stops if the expression is true.

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).

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).

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).

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.

Suspends all the processes in pgrp.

Suspends the process pid if it is in the dbx process pool. If it is not running, this command does nothing.

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.

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.

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.

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.

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.

Searches the tag file for the given procedure.

Whenever the specified variable changes, dbx prints the old and new values of that variable.

Prints the values of the parameters passed to the specified procedure whenever your program calls it. Upon return, dbx prints the return value.

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).

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).

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).

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).

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).

This command is equivalent to entering traceprocedure. (For machine-level debugging.)

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).

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).

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).

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).

Removes the specified alias.

Turns off the specified recording session(s) and closes the file(s) involved.

Turns off all recording sessions and closes all files involved.

Removes the specified dbx variable.

Removes the specified environment variable.

Moves up the specified number of activation levels in the stack. The default is one level.

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.

Waits for the active process to stop for an event.

Waits for the process pid to stop for an event.

Waits for any process currently running to breakpoint or stop for any reason.

Prints the type declaration for name.

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).

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).

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).

Evaluates the expression before executing each source line. If it is true, executes the command list.

Evaluates the expression at the given source line. If it is true, executes the command list.

Evaluates the expression at every source line within a given procedure. If it is true, executes the 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).

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).

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).

Evaluates the expression before executing each machine instruction. If the expression is true, executes the command list.

Evaluates the expression at the given address. If the expression is true, executes the command list. (For machine-level debugging.)

Evaluates the expression in the given procedure. If the expression is true, executes the command list. (For machine-level debugging.)

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).

Tests both conditions at every machine instruction within a given procedure. If they are true, executes the command list.

Print a stack trace. t is an alias for the where command.

Prints the fully qualified names of all versions of name. The range of objects examined is determined by $whereisdsolimit.

Prints the fully qualified name of the active version of name.

Lists the dynamic shared objects that contain variable.