The modes are:

d	Print a short word in decimal
u	Print a short word in unsigned decimal
D	Print a long word in decimal
U	Print a long word in unsigned decimal
o	Print a short word in octal
O	Print a long word in octal
x	Print a short word in hexadecimal
X	Print a long word in hexadecimal
b	Print a byte in hexadecimal
c	Print a byte as a character
s	Print a string of characters (a C-style string that ends in null)
f	Print a single-precision real number
g	Print a double-precision real number
i	Disassemble machine instructions

To repeat a command line entered during the current debugging session, enter an exclamation point followed by the integer associated with the command line. (Use the history command to see a list of commands used.) For example, to repeat the seventh command used in the current debugging session, enter !7. Enter !-3 to repeat the third-to- last command.

To repeat the most recent command starting with a string, use the last form of the command. For example, to repeat a command that started with bp, enter !bp.

The search begins from the current position of the program counter. If no program counter exists for the current source file, the search begins after the last source line displayed by the debugger.

Use the second form to define a new alias or to redefine an existing alias. The definition can contain:

• The name of another alias, if the nested alias is the first identifier in the definition; for example, you can define a nested alias and invoke the alias as follows:

  (ladebug) alias begin "stop in main; run" 
  (ladebug) alias pv(x) "begin; print(x)" 
  (ladebug) pv(i) 
  

• A string in quotation marks, specified with backslashes before the quotation marks, as in the following two examples:

  (ladebug) alias x "set $lang=\"C++\" " 
  (ladebug) alias x  
  x       set $lang="C++"
  (ladebug)
  

  (ladebug) alias ada "ignore sigalrm; ignore sigfpe; set $lang=\"Ada\";" 
  (ladebug) alias ada
  ada     ignore sigalrm; ignore sigfpe; set $lang="Ada";
  (ladebug)
  

Note that in the first example there is a space between the last two quotation marks. In the second example there is a semicolon. The two quotation marks cannot be together; they must be separated by a space or character(s).

Invoke the alias by entering the alias name, including an argument if the alias definition specified an argument.

Use the unalias command to delete an alias.

Alias commands can contain no more than 56 arguments.

The following predefined aliases are included with the debugger:

S       next
Si      nexti
W       list $curline - 10:20
a       assign
b       stop at
bp      stop in
c       cont
d       delete
e       file
f       func
g       goto
h       history
j       status
l       list
li      ($curpc)/10 i; set $curpc = $curpc + 40
n       next
ni      nexti
p       print
pd      printf "%ld",
pi      playback input
po      printf "0%o",
pr      printregs
ps      printf "%s",
px      printf "0x%lx",
q       quit
r       rerun
ri      record input
ro      record output
s       step
si      stepi
t       where
tlist   show thread (only defined during kernel debugging)
tset    thread (only defined during kernel debugging)
u       list $curline - 9:10
w       list $curline - 5:10
wi      ($curpc - 20)/10 i

For C++, use this syntax:

   assign [classname::]member = ["filename"] `expression
   assign [object.]member = ["filename"] `expression

For C++, use the assign command to modify static and object data members in a class, and variables declared as reference types, type const, or type static. The address referred to by a reference type cannot be changed, but the value at that address can be changed.

You can nest called functions by setting a breakpoint in a function and executing it using the call command. When execution suspends at the breakpoint, use this command to execute the nested function.

For multithreaded applications, the call is made in the context of the current thread.

For C++: When you set the $overloadmenu debugger variable to 1 and call an overloaded function, the debugger will list the overloaded functions and call the function you specify.

Only one signal at a time can be added to, or removed from, the list of trapped or ignored signals.

The catch and ignore commands operate on a per program basis; you must first load a program (using the load command) or attach to a process (using the attach command).

Setting the class scope nullifies the function scope.

For multithreaded applications, use the cont command to resume execution of the current thread that was put on hold. As the current thread resumes, the other threads run freely.

The signal parameter value can be either a signal number or a string name (for example, SIGSEGV). The default is 0, which allows the program to continue execution without specifying a signal. If you specify a signal parameter value, the program continues execution with that signal.

Enter the delete all command or the delete * command to remove all breakpoints and tracepoints.

This command operates on a per program basis; you must first load a program (using the load command) or attach to a process (using the attach command).

The disabled breakpoint is displayed in response to the status command but it is ignored during execution. Disabled breakpoints remain disabled until they are explicitly reactivated or deleted.

This command operates on a per program basis; you must first load a program (using the load command) or attach to a process (using the attach command).

When the function scope changes, the debugger displays the source line corresponding to the last point of execution in that function.

Enter the dump. command (include the dot) to list the parameters and local variables for all functions active on the stack.

Enter the enable all command or the enable * command to activate all previously disabled breakpoints and traces.

This command operates on a per program basis; you must first load a program (using the load command) or attach to a process (using the attach command).

This command is not for the current debuggee's environment, but for the environment of any debuggees subsequently created with fork(2) or with subsequent run or rerun commands.

export and setenv are synonyms.

See Chapter 9 for more information on commands that manipulate the environment of subsequent debuggees.

When the function scope is changed, the debugger displays the source line corresponding to the last point of execution in that function.

Only one signal at a time can be added to, or removed from, the list of trapped or ignored signals.

The catch and ignore commands operate on a per program basis; you must first load a program (using the load command or attach to a process (using the attach command).

To display the source code for a particular function, enter the function as an argument.

The unload command removes all related symbol table information that the debugger associated with the process being debugged, specified by either a process ID or image file.

For multithreaded applications, use these commands to step the current thread while putting all other threads on hold.

For multithreaded applications, use these commands to step the current thread while putting all other threads on hold.

Use this command exclusively when you need to change the ondisk binary. Use the assign command when you need only to modify debuggee memory.

If the image is executing when you issue the patch command, the corresponding location in the debuggee address space is updated as well. (The debuggee is updated regardless of whether the patch to disk succeeded, as long as the source and destination expressions can be processed by the assign command.) If the user program is loaded but not yet started, the patch to disk is performed without the corresponding assign to memory.

When a command file is executed the value of the $pimode debugger variable determines whether the commands are echoed. If the $pimode variable is set to 1, commands are echoed; if $pimode is set to 0 (the default), commands are not echoed. The debugger output resulting from the commands is always echoed.

See Chapter 9 for more information.

The print @line_number command displays the address of the specified line number. For example, print @10 displays the address of line number 10.

For C++:

   print *this
   print object
   print [object.]member
   print *( derived_class *) object

For C++, use the print command to display the value of an object, including inherited members and the value of data members in an object. Type casts can be used to interpret a base class object as a derived class object, or to interpret a derived class object as a base class object. To interpret a base class type object as the derived type, use the print * command.

This command is not for the current debuggee's environment, but for the environment of any debuggees subsequently created with fork(2) or with subsequent run or rerun commands.

See Chapter 9 for more information on commands that manipulate the environment of subsequent debuggees.

The record output command saves all debugger output to a file. The output is simultaneously echoed to the screen. (The program output is not saved.)

The record io command saves both input to and output from the debugger.

To stop recording debugger input or output, exit the debugger.

If the last modification time and/or size of the binary file or any of the shared objects used by the binary file has changed since the last run command was issued, Ladebug automatically rereads the symbol table information. If this happens, the old breakpoint settings may no longer be valid after the new symbol table information is read.

To define a debugger variable, enter the set command followed by a variable name, an equal sign, and a definition. Enclose string definitions in quotes. The definition can be any expression allowed by the language of the program being debugged.

Use the unset command to delete a variable.

If you want to remove an environment variable, or all environment variables, use the unsetenv command, not the unset command.

The debugger contains many predefined variables to describe the current state of the debugger, and to allow you to customize the debugger environment. You can delete and redefine the predefined debugger variables in the same way you define your own variables. If you delete a predefined debugger variable, the debugger uses the default value for that variable. The settings on the predefined variables apply to all debugging processes.

The debugger has the following predefined variables:

$ascii	With the default value of 1, allows the print command to print character-type data as ASCII characters, only when the bit value is that of a printable 7-bit subset ASCII character. (Other bit values are printed as octal numbers.) With a value of 0, this variable causes all printable ISO Latin- 1 characters to be printed as characters.
$beep	With the default value of 1, causes a beep to sound when a user attempts to perform an illegal action while editing the debugger command line (for example, moving the cursor past the end of the line, or "yanking"-pasting - from an empty cut buffer).
$childprocess	Can be specified in place of the process ID. (Ladebug automatically sets this variable when an application forks a child process.)
$catchexecs	When set to 1, instructs the debugger to notify the user and stop the program when a program execs. The default is 0.
$catchforks	When set to 1, instructs the debugger to notify the user when a program forks a child process. The child process stops and is brought under debugger control. (By default, the parent process is not stopped. See the $stopparentonfork description.) The default is 0.
$curevent	Is set to the event number of the current event at the start of an event, allowing its use within the expression of an event.
$curfile	Specifies the current source-code file.
$curline	Specifies the current line in the source file.
$curpc	Specifies the current point of program execution. This variable is used by the wi and li aliases.
$cursrcline	Specifies the line number of the last line of source code listed plus one.
$curthread	Indicates the thread ID of the current thread within the current process. You can change to a different thread by setting $curthread.
$decints	When set to 1, all integers printed by the debugger are displayed as decimal numbers. The default is 0.
$editline	With the default of 1, enables the command-line editing features. The command- line editing features are described in Chapter 7. For backward compatibility you can set this variable to 0.
$eventecho	When set to 1, echoes events (such as breakpoints) with event numbers when executed. The default is 1.
$hasmeta	For international users. When set to 1, causes any 8- bit character to be interpreted as the corresponding 7-bit character plus the Meta character (which is the ALT key whose MSB bit represents a Meta modifier). This could be used for binding editing functions to ALT plus key sequences. The default depends on several factors, including the locale and whether the terminal has Meta capability. In the United States, the default is usually 0.
$hexints	When set to 1, all integers will be displayed as hexadecimal numbers. The default is 0.
$historylines	Specifies the number of previously input commands listed in response to the history command. The default is 20.
$indent	When set to 1, specifies that structures will be printed with added indentation to render them more readable. The default value is 1.
$lang	Specifies the programming language used in the program being debugged. For mixed-language programs, $lang is set to the language corresponding to the current frame. The variable is updated when the program execution stops.
$listwindow	Specifies how many lines the list command displays. The default is 20.
$main	Specifies the name of the function that the debugger enters first. The default is main() , but this can be set to any function. This variable is useful when debugging languages whose primary function is called something other than main() .
$maxstrlen	Specifies the maximum number of characters to print when the value of a string is printed. The default is 128.
$octints	When set to 1, the debugger prints all integers as octal numbers. The default is 0.
$overloadmenu	When debugging C++ programs only, if this variable is set to 1, a menu of overloaded functions is displayed so you can select the desired function from the list of type signatures of the function. When set to 0, no menu is displayed and you must disambiguate overloaded functions by providing the full type signature. The default is 1.
$parentprocess	Can be specified in place of the process ID. (Ladebug automatically sets this variable when an application forks a child process.)
$pid	Indicates the process ID of the current process. Only for use in kernel debugging (either local or remote).
$pimode	Specifies whether the playback input command echoes input. If set to 1, commands from the script file are echoed. If set to 0, commands are not echoed. The default is 0.
$prompt	Specifies the debugger prompt. The default is (ladebug).
$repeatmode	When set to 1, causes the debugger to repeat the previous command if you press the Return key at the (ladebug) prompt. The default is 1.
$stackargs	When set to 1, causes the values of arguments to be included in the output of the where, up, down , and dump commands. When large or complex values are passed by value, the output can be voluminous. You can set $stackargs to 0 to suppress the output of argument values. The default is 1.
$stepg0	When set to 0, the debugger steps over calls to routines that are compiled without symbol information. When set to 1, the debugger steps into these calls. The default is 0.
$stoponattach	When set to 1, causes the debugger to stop a running process right after attaching to it. When set to 0, causes the debugger to allow the process to run to completion; in this case, to interrupt the process, enter Ctrl/C. The default is 0.
$stopparentonfork	When set to 1, instructs the debugger to stop the parent process when a program forks a child process. (Also see the $catchforks description.) The default is 0.
$threadlevel	Enables Ladebug to determine whether you are working with DECthreads or native threads. The default is decthreads if the application is multithreaded and is using DECthreads. Otherwise, the default is native. You can switch from one mode to the other by setting $threadlevel. In kernel mode, $threadlevel is always native.
$tid	Indicates the thread ID of the current thread within the current process. You can change to a different thread by setting $tid. Only for use in kernel debugging (either local or remote).
$verbose	When set to 1, specifies whether debugger output should include all possible program information, including base pointers and virtual function pointers (for C++ programs only). The default is 0.

This command is not for the current debuggee's environment, but for the environment of any debuggees subsequently created with fork(2) or with subsequent run or rerun commands.

export and setenv are synonyms.

See Chapter 9 for more information on commands that manipulate the environment of subsequent debuggees.

Example:

(ladebug) sh ls -l sample.c  

Use the show condition with state == wait command to display information only for condition variables that have one or more threads waiting. If $verbose is set to 1, the sequence numbers of the threads waiting on the condition variables are displayed.

Use the show mutex with state == locked command to display information exclusively for locked mutexes. If $verbose is set to 1, the sequence numbers of the threads locking the mutexes are displayed.

Use the show thread with state command to list only the threads with a specific state (characteristic).

The valid state values for DECthreads are ready, blocked, running, terminated, and detached.

The valid state values for native theads are stopped, running, and terminated.

When a command file is executed, the value of the $pimode debugger variable determines whether the commands are echoed. If the $pimode variable is set to 1, commands are echoed; if $pimode is set to 0 (the default), commands are not echoed. The debugger output resulting from the commands is always echoed.

For multithreaded applications, use these commands to step the current thread while putting all other threads on hold.

For multithreaded applications, use these commands to step the current thread while putting all other threads on hold.

Enter the stop command with a variable argument to suspend program execution when the variable changes.

Specify if with an expression to suspend execution when the expression evaluates to true. When you specify both an expression and a variable, execution suspends only if the specified expression evaluates to true and the variable has changed.

To suspend execution when a line or function is encountered, use the third, fourth, or fifth syntax form. If you specify a variable, execution suspends only if the variable has changed when the line or function is encountered.

If you specify an expression, execution suspends only if the expression evaluates to true when the line or function is encountered.

If you specify both a variable and an expression, execution suspends only if the variable has changed and the expression evaluates to true when the line or function is encountered.

Specify a filename and function to instruct Ladebug to stop in a particular function in the specified file, thus eliminating ambiguity.

Use the seventh and eighth forms of the syntax for multithreaded applications. The thread_identifier_list parameter identifies one or more threads of the current debugging level (native or DECthreads). If you specify one or more thread identifiers, the breakpoint is set only in those threads. If you do not specify any thread identifier, the breakpoint is set on all threads or at the process level.

The following example shows how to suspend program execution when line number 10 is encountered and the variable f equals 2:

(ladebug) stop at 10 if f==2 

For C++:

   stop in [classname::]function
   stop in object.function
   stop in objectptr->function
   stop in object.function if (& object == this)
   stop in [classname::]classname (type_signature)
   stop in [classname::]~classname
   stop in [classname::] function [(type_signature)] [(void)]
   stop in all function

For C++ only.

The first form of the stop command sets a breakpoint in a member function using the static class type information. This form presumes that run-time information from an object is needed to determine the address of the function at which to set the breakpoint.

If you need run-time information to determine the correct virtual function, use the second or third syntax form to qualify the function name with the object when you set the breakpoint. This way of setting the breakpoint causes the debugger to stop at the member function in all objects declared with the same class type as the specified object.

To set a breakpoint that stops only in the member function for this specific object and not all instances of the same class type, use the fourth form of the stop command.

The fifth and sixth syntax forms set breakpoints in a constructor and destructor, respectively.

To set a breakpoint in a specific version of an overloaded function, either set $overloadmenu to 1, enter the command stop in function , and choose the appropriate function from the menu, or specify the function and the type signature as arguments to the command. If the overloaded function has no parameters, void must be explicitly specified.

Use the last form to set a breakpoint in all versions of an overloaded function.

Example:

(ladebug) stop at 10 if f==2

Specify if with an expression to suspend execution when the expression evaluates to true. When you specify both a variable and an expression, execution suspends only if the specified expression evaluates to true and the variable has changed.

To suspend execution when an address is encountered, use the third syntax form. If you specify a variable, execution suspends only if the variable has changed when the address is encountered. If you specify an expression, execution suspends only if the expression evaluates to true when the address is encountered. If you specify both a variable and an expression, execution suspends only if the variable has changed and the expression evaluates to true when the address is encountered.

The stopi command is different from the stop command because the debugger checks the breakpoint set with the stopi command after executing each machine instruction. Thus, the debugger performance is affected when you use the stopi command.

As of Version 4.0 of the debugger, the stopi in command is no longer valid, and results in an error message. Replace stopi in in your code with stopi at for an address or stop in for a routine.

The debugger interprets the thread identifier as a DECthreads or kernel thread identifier depending on the value of the debugger variable $threadlevel.

To print a message when a line or function is encountered, use the second or third syntax form.

If you specify a variable, a message is printed only if the variable has changed when the line or function is encountered.

If you specify an expression, a message is printed only if the expression evaluates to true when the line or function is encountered.

If you specify both a variable and an expression, a message is printed only if the variable has changed and the expression evaluates to true when the line or function is encountered.

The following example traces the variable f when the program is executing the function main:

(ladebug) trace f in main 

Use the trace thread command to set tracepoints in specific threads. If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify. If you omit the thread identifier specification, the debugger sets a tracepoint in all the threads of the application.

To print a message when an address or function is encountered, use the second or third syntax form.

If you specify a variable, a message is printed only if the variable has changed when the address or function is encountered.

If you specify an expression, a message is printed only if the expression evaluates to true when the address or function is encountered.

If you specify both a variable and an expression, a message is printed only if the variable has changed and the expression evaluates to true when the address or function is encountered.

The tracei command differs from the trace command in that the debugger evaluates the tracepoint set with the tracei command after the debugger executes each machine instruction. Thus, when you use the tracei command, the debugger performance is affected.

In the following example, a breakpoint is set to print a message every time the function factorial is entered:

(ladebug) tracei factorial

Use the tracei thread command to set tracepoints in specific threads. If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify. If you omit the thread identifier specification, the debugger sets a tracepoint in all the threads of the application.

This command is not for the current debuggee's environment, but for the environment of any debuggees subsequently created with fork(2) or with subsequent run or rerun commands.

See Chapter 9 for more information on commands that manipulate the environment of subsequent debuggees.

When the function scope changes, the debugger displays the source line corresponding to the last point of execution in that function.

Enter the unuse command without an argument to set the search list to the default, the home directory, the current directory, and the directory containing the executable file. Include the name of a directory to remove it from the search list. The asterisk * argument removes all directories from the search list.

For C++:

   whatis classname
   whatis [classname::]member
   whatis [classname::]function

The first syntax form of the whatis command for C++ displays the class type. The second form displays the type of a member function or data member. To display all versions of an overloaded function, use the third form.

To execute a command when an expression evaluates to true, use the second syntax form. To execute commands when a line or function is encountered, use the third or fourth syntax form.

If you specify an expression, the command is executed only if the expression evaluates true when the line or function is encountered.

Example:

(ladebug) when at 5 {list;where} 

Use the when thread command to set tracepoints in specific threads. If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify. If you omit the thread identifier specification, the debugger sets a tracepoint in all the threads of the application.

To execute a command when an expression evaluates to true, use the second syntax form. To execute a command when an address or function is encountered, use the third or fourth form.

If you specify an expression, the command is executed only if the expression evaluates to true when the address or function is encountered.

The wheni command differs from the when command in that the debugger evaluates the tracepoint set with the wheni command after each machine instruction is executed. Thus, using the wheni command affects performance.

For example, the following command stops program execution, lists ten lines of source code and displays the stack trace when the value of the variable i is equal to 3 in the function main:

(ladebug) wheni in main if i == 3 {wi;where}

Use the wheni thread command to set tracepoints in specific threads. If you list one or more thread identifiers, the debugger sets a tracepoint only in those threads you specify. If you omit the thread identifier specification, the debugger sets a tracepoint in all the threads of the application.

Include the optional number argument to see a specified number of levels at the top of the stack. (Each active function is designated by a number, which can be used as an argument to the func command. The top level on the stack is 0; so if you enter the command where 3 , you will see levels 0, 1, and 2.) If you do not specify the number argument, you will see all levels.