 |
Index for
Section 1 |
|
 |
Alphabetical
listing for L |
|
 |
Bottom of
page |
|
ladebug(1)
NAME
ladebug - Invokes the Ladebug debugger
SYNOPSIS
ladebug
[-c file]
[-gui]
[-i file]
[-I directory]
[-k]
[-line serial_line]
[-nosharedobjs]
[-parallel]
[-pid process_id [executable_file]]
[-prompt string]
[-remote]
[-rp remote_debug_protocol]
[-tty terminal_device]
[-V]
[executable_file [core_file]]
DESCRIPTION
The Ladebug debugger is a symbolic source code debugger that debugs
programs compiled by the DEC C, ACC, DEC C++, DEC Ada, DEC COBOL, DEC
Fortran 90, and DEC Fortran 77 compilers. For full source-level debugging,
compile the source code with the compiler option that includes the symbol
table information in the compiled executable file.
Command-Line Options and Parameters
-c Specifies an initialization command file. The default initialization
file is .dbxinit. By default, the debugger searches for this file
during startup, first in the current directory; if it is not there, the
debugger searches your home directory for the file. This file is
processed after the Ladebug debugger has connected to the application
being debugged.
-gui
Activates the Ladebug debugger's graphical user interface (GUI) as well
as the command-line interface.
-i Specifies a pre-initialization command file. The default pre-
initialization file is .ladebugrc. By default, the debugger searches
for this file during startup, first in the current directory; if it is
not there, the debugger searches your home directory for the file. This
file is processed before the Ladebug debugger has connected to the
application being debugged, so that commands such as "set $stoponattach
= 1" will have taken effect when the connection is made.
-I Specifies the directory containing the source code for the target
program, in a manner parallel to the use command. Use multiple -I
options to specify more than one directory. The debugger searches
directories in the order in which they were specified on the command
line.
-k or -kernel
Enables local kernel debugging.
-line
Specifies the serial line for remote kernel debugging. This must be
used with -rp kdebug.
-nosharedobjs
Prevents the reading of symbol table information for any shared objects
loaded when the program executes. Later in the debug session, the user
can enter the readsharedobj command to read in the symbol table
information for a specified object.
-parallel
For Ladebug Version 67, enables parallel debugging for applications
using Message Passing Interface (MPI) or Unified Parallel C (UPC).
Earlier versions of Ladebug do not support this capability.
-pid
Specifies the process ID of the process to be debugged. You may
optionally also specify the binary file for that process. This option
cannot be used with any remote or kernel debugging flags.
-prompt
Specifies a debugger prompt. The default debugger prompt is "(ladebug)
". If the prompt argument contains spaces or special characters,
enclose the argument in quotation marks (" ").
-remote
Enables remote kernel debugging; for use with the kdebug kernel
debugger.
-rp Specifies the remote debug protocol. Currently only kdebug is
supported. -rp kdebug enables remote kernel debugging.
-tty
Specifies the terminal device for remote kernel debugging. This must be
used with -rp kdebug.
-V Causes the Ladebug debugger to print its version number and exit
without starting a debugging session.
executable_file
Specifies the program executable file. If the file is not in the
current directory, specify the full pathname.
core_file
Specifies the core file. If the core file is not in the current
directory, specify the full pathname.
Entering Commands
At the debugger prompt, you may enter more than one command on the same
line by separating each command with a semicolon. Commands are executed in
the same order in which they are entered in the command line.
Continue command input to another line by entering a backslash at the end
of each line. The maximum command-line length is 100,000 characters.
In Ladebug debugger commands, the words thread, in, at, state, if, policy,
priority, and with are command language keywords and must be surrounded by
parentheses in expressions that use them as variables or type names.
Task-related Command Sets
The following section lists the Ladebug debugger commands in task-related
sets:
Starting and stopping programs in the debugger: attach, detach, kill, load,
quit, rerun, run, unload For examples, enter help start.
Stopping your program at specific locations: delete, disable, enable,
status, stop, stopi, when, wheni For examples, enter help breakpoint.
Controlling the execution of your program: call, cont, conti, goto, next,
nexti, return, step, stepi For examples, enter help execution.
Saving the current state of the debuggee process in a snapshot: save
snapshot, clone snapshot, delete snapshot, show snapshot For examples,
enter help snapshot.
Reading and writing memory, variables, and registers: assign, dump,
examine_address, print, printb, printf, printi, printregs, printt,
search_memory, trace, tracei, watch For examples, enter help variable, help
memory, or help register.
Looking at the call stack: down, pop, up, where For examples, enter help
stack.
Showing the source for the program: /, ?, file, edit, list, unuse, use, map
source directory, unmap source directory, show source directory For
examples, enter help listing.
Examining or changing the current scope under investigation: class, down,
file, func, process, thread
Manipulating processes: attach, detach, kill, process, show process
Manipulating threads and thread-specific objects: show condition, show
mutex, show thread, thread
Learning specifics about program variables: whatis, whereis, which
Manipulating shared objects: delsharedobj, listobj, readsharedobj
Controlling signal handling: catch, ignore
Parallel debugging commands: focus, show process set, show aggregated
message, expand aggregated message
Changing or understanding your Ladebug environment: alias, set, help,
unalias, unset For a complete list of debugger variables, enter help
$variable.
Changing or showing the current system environment: export, printenv,
setenv, sh, unsetenv
Logging the results of Ladebug debugger commands and replaying a log: #,
playback, record, unrecord, source
Recalling previously-used commands: !, history
Debugging UNIX kernels: kps, patch There are also a number of kernel
debugging command aliases such as tlist and tstack available. Enter alias
for a complete list of command aliases.
Command Descriptions
address_expression / [count][mode]
address_expression ? [count][mode]
address_expression , address_expression / [mode]
address_expression / [count] search_mode value mask
address_expression ? [count] search_mode value mask
address_expression , address_expression / search_mode value mask
The first, second, and third commands are examine_commands that allow
you to display memory.
The first examine_command displays the count number of memory values in
the requested format, starting at address_expression. If count is not
specified, 1 is assumed. The count value must be a positive value. If
you want to see memory values leading up to the address_expression, use
the second examine_command. The second examine_command displays count
number of memory values in the requested format ending at the
address_expression. If count is not specified, 1 is assumed. The count
value must be a positive value.
The third examine_command displays memory values in the requested
format starting at the smaller of the two address_expressions and
ending at the larger address_expression.
You can display stored values in the following formats by specifying
mode. If mode is not specified, the mode used in the previous / command
is assumed. If no previous / command exists, X is assumed. The modes
are:
b Print a byte in hexadecimal.
c Print a byte as a character.
C Print a wide character as a character.
d Print a short word in decimal.
D Print a long word in decimal.
dd Print a 32-bit (4 byte) decimal display.
f Print a single-precision real number.
g Print a double-precision real number.
i Disassemble machine instructions.
L Print a long double precision real number.
o Print a short word in octal.
O Print a long word in octal.
oo Print a 32-bit (4 byte) octal display.
s Print a string of characters (a C-style string that ends in null).
S Print a null terminated string of wide characters.
u Print a short word in unsigned decimal.
U Print a long word in unsigned decimal.
uu Print a 32-bit (4 byte) unsigned decimal display.
x Print a short word in hexadecimal.
X Print a long word in hexadecimal.
xx Print a 32-bit (4 byte) hexadecimal display.
The fourth, fifth, and sixth commands are search_commands that allow
you to search memory. Use the address_expression and count to determine
the range of memory to search. If count is not specified, 1 is assumed.
The count value must be a positive value. Use the search_mode to
specify whether you want to search 32 or 64-bit chunks. The debugger
will start at the specified starting address and read a chunk of memory
(either 32 or 64 bits in size) and apply the mask and comparison on
that chunk of memory. Use the value to specify the memory value to
seek. Use the mask to specify those bits that must match the same bits
in the specified value. To ensure that a possible match will be found,
the debugger applies the mask to the input value prior to starting the
search, to remove any bits that could prevent a match from occurring.
Then, for each memory location searched, the debugger applies the mask
to the memory value and then compares it with this new input value. If
a match is found, then the address and memory value are displayed.
# comment
When the debugger encounters the # command, it ignores all inputs until
the end of the line. The # command must be the first identifier on the
command line. (White space can precede this command.)
!! or ![-]integer or !text
To repeat the last command line, enter two exclamation points or press
the Return key. You can also enter !-1.
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.
/ [string] or ? [string]
Use the string search commands / and ? to locate text in the source
code. The / character invokes a forward search; the ? character invokes
a backwards search. Enter / or ? without an argument to find the next
location of the previously specified text.
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.
alias [aliasname]
alias aliasname [(argument ,...)] "string"
unalias aliasname
Enter the alias command without an argument to display all aliases and
their definitions. Specify an alias name to display the definition for
that alias.
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)
The definition can contain a string in quotation marks, specified with
backslashes before the quotation marks, as in the following example:
(ladebug)alias x "set $lang=\"C++\""
(ladebug) alias x
x set $lang="C++"
Invoke the alias by entering the alias name, including any arguments
specified in the alias definition.
Use the unalias command to delete an alias.
Alias commands cannot contain more than 56 arguments.
The following predefined aliases are included with the debugger:
a assign
att attach
b stop at
bp stop in
c cont
d delete
det detach
e file
f func
g goto
h history
j status
l list
li $cursrcpc/10i; set $cursrcpc=$cursrcpc+40
n next
ni nexti
p print
pi playback input
plist
show process all
pr printregs
ps printf "%s",
q quit
r rerun
ri record input
ro record output
s step
S next
si stepi
Si nexti
sw switch
switch
process
t where
tlist
show thread all (show thread when the kernel debugging option is
used)
ts where thread all
tset
thread
tstack
where thread all
u list $curline-9:10
w list $curline-5:10
W list $curline-10:20
wi ($curpc-20)/10i
wm watch memory
wv watch variable
assign target = expression
Use the assign command to change the value of a variable, memory
address, or expression that is accessible according to the scope and
visibility rules of the language. The expression can be any expression
that is valid in the current context.
For C++:
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.
attach process_id [image_file]
Use the attach command to connect to a running process. Supply the
process ID number; the image file name is optional.
call function([parameters])
Use the call command to execute a single function. Specify the
function as if you were calling it from within the program. If the
function has no parameters, specify empty parentheses.
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 the call 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 lists the overloaded functions and
calls the function you specify.
catch [signal]
Enter the catch command without an argument to see which operating
system signals the debugger currently traps. Use the catch command
followed by an argument to trap the specified signal.
Only one signal at a time can be added to the list of trapped signals.
The catch 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).
catch unaligned
Enter the catch unaligned command to instruct the debugger to stop when
unaligned data access occurs in the debuggee process. The debugger
stops at the instruction following the instruction where the unaligned
access occurs, and issues a message. The default is ignore unaligned.
class [classname]
For C++ only:
Use the class command without an argument to display the current class
scope. Specify an argument to change the class scope. Once the class
scope is set, refer to members of the class omitting the classname::
prefix.
Setting the class scope nullifies the function scope.
clone snapshot [integer]
Use the clone snapshot command to clone (copy) the snapshot specified
by the integer argument. If no integer is specified, the most recently
saved existing snapshot is cloned. There are two side-effects to
cloning a snapshot. First, the snapshots in the future of the cloned
snapshot are deleted. For example, suppose four snapshots are saved
from a process. Cloning the second snapshot results in the deletion of
the third and fourth snapshots. Second, the current process is killed
and replaced by the cloned process. Thus if you enter show process
after cloning a snapshot, you will see that the process ID of the
current process has changed to that of the cloned process.
See also save snapshot, delete snapshot, and show snapshot.
Limitations:
The state saved in a snapshot doesn't cover I/O and forks. In other
words, when you clone a snapshot, the I/O that has been done since the
snapshot was saved is not undone; likewise, child processes that have
been spawned since the snapshot was saved are not killed.
[count] cont [signal] [to-linenumber] [in-function]
conti to-address
Use the cont command without an argument value to resume program
execution until a breakpoint, a signal, an error, or the end of the
program is encountered.
Specify the count argument to cause the debugger to automatically
repeat the command count times. Specify a signal parameter value to
send an operating system signal to the program continuing execution.
Specify the linenumber argument to halt program execution when that
line number is reached. Specify the in-function argument to halt the
program when the named function is reached.
Use the conti form of the command to halt program execution when the
specified code address is executed.
When you use the cont command, the Ladebug debugger resumes execution
of the entire process.
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. If both a count and a signal are specified, the signal will
only be sent on the first continuation.
The linenumber argument is used to resume execution and then halt when
the specified source line is reached.
The form of the optional linenumber argument must be either linenumber,
a positive numeric, which indicates the line number of the current
source file where execution is to be halted, or "filename":linenumber,
which explicitly identifies both the source file and the line number
where execution is to be halted.
The function argument is used to continue until the named function is
reached. If the function name is overloaded and the user does not
resolve the scope of the function in the command line, the debugger
prompts the user with the list of overloaded functions bearing that
name from which to choose.
The form of the optional function argument must be a valid function
name.
delete integer ,...
delete all
delete *
Enter the delete command followed by the number or numbers associated
with a breakpoint, trace, or watch (as listed by the status command) to
remove the specified breakpoint, tracepoint, or watchpoint.
Enter the delete all command or the delete * command to remove all
breakpoints, tracepoints, or watchpoints.
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).
delete snapshot *
delete snapshot all
delete snapshot [integer ,...]
The first two forms of this command delete all the snapshots that have
been saved from the current process. The last form deletes the
snapshots specified. If no snapshots are specified, the most recently
saved existing snapshot is deleted.
See also save snapshot, clone snapshot, and show snapshot.
delsharedobj shared_object
Use the delsharedobj command to remove the symbol table information for
the specified shared object from the debugger.
detach [process_id ,...]
Use the detach command with process IDs to detach from the specified
running process or processes. Use the show process all or show process
* command to display a list of processes running under debugger
control. If you do not specify a process ID, the debugger detaches from
the current process. Detaching from a process disables your ability to
debug that process.
disable integer ,...
disable all
disable *
Enter the disable command followed by the number or numbers associated
with a breakpoint, trace, or watch (as listed by the status command) to
disable the breakpoint, tracepoint, or watchpoint. Enter the disable
all command or the disable * command to disable all breakpoints,
tracepoints, or watchpoints.
The disabled breakpoint is displayed in response to the status command,
but 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).
down [number]
Use the up command or the down command without an argument to change
the function scope to the function located one level up or down the
stack. Enter a number argument to change the function scope to the
function up or down the specified number of levels. If the number of
levels exceeds the number of active functions on the stack, the
function scope moves up or down as many levels as possible and the
debugger issues a warning message.
When the function scope changes, the debugger displays the source line
corresponding to the last point of execution in that function.
dump [function]
dump.
Use the dump command without an argument to list the parameters and
local variables in the current function. To list the parameters and
local variables in an active function, specify it as an argument.
Enter the dump. command (include the dot) to list the parameters and
local variables for all functions active on the stack.
edit [filename]
Enter the edit command without an argument to edit the current source
file. Include the filename argument to edit the specified file. The
Ladebug debugger will use the value of the EDITOR environment variable
to pick the editor to invoke. The default is vi.
enable integer ,...
enable all
enable *
Enter the enable command followed by the number or numbers associated
with a breakpoint, trace, or watch (as listed by the status command) to
enable a breakpoint, tracepoint, or watchpoint.
Enter the enable all command or the enable * command to activate all
previously disabled breakpoints, tracepoints, and watchpoints.
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).
expand aggregated message message_id_list
expand aggregated message
Enter the expand aggregated message command to expand the specified
messages. If no message_id is specified, the debugger expands the most
recently added (newest) message.
export [env_variable [=value]]
Sets the value of the specified environment variable. If no variable is
specified, the command displays the values of all environment
variables. If a variable is specified but no value is specified, the
variable is set to NULL.
This command is not for the current debuggee's environment, but for the
environment of any debuggees created with subsequent run or rerun
commands.
Note that export and setenv are synonyms.
file [filename]
Enter the file command without an argument to display the name of the
current file scope. Include the filename argument to change the file
scope. Change the file scope to set a breakpoint in a function not in
the file currently being executed. To see source code for a function
not in the file currently being executed, use the file command to set
the file scope and the use command to direct the search for the sources
of that file.
focus expression
focus all
focus
The first form of the command sets the current process set to the set
resulting from the evaluation of the given expression. The second form
sets the current process set to the set that includes all processes.
The third form displays the current process set.
func [function]
func [integer]
Use the func command without an argument to display the current
function scope. To change the function scope to a function currently
active on the stack, specify either the name of the function or the
number corresponding to the stack activation level. (Enter the where
command to display the stack trace.)
When the function scope is changed, the debugger displays the source
line corresponding to the last point of execution in that function.
goto linenumber
Use the goto command to branch to a line located in the function where
execution is suspended. When you branch to a line, the source code
between the line where execution suspended and the specified line is
not executed.
help [command] [ladebug]
Enter the help command without an argument to display a list of
debugger help topics. Include a command argument to display a
description of that command. Include a ladebug argument to display a
task-oriented list of commands.
history [integer]
Enter the history command without an argument to display previously
executed commands. The debugger displays the number of command lines
defined for the $historylines debugger variable. (The default is 20
lines of user input.) Include an integer argument to display that
number of previous commands.
if expression {command[;...]} [else {command[;...]}]
In this command, the first command list is executed if expression
evaluates to a nonzero value and the second command list is executed
(if it is specified) otherwise.
ignore [signal]
Enter the ignore command without an argument to see which operating
system signals the debugger currently ignores. Use the ignore command
followed by an argument to ignore the specified signal.
Only one signal at a time can be removed from, the list of ignored
signals.
The ignore 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).
ignore unaligned
Enter the ignore unaligned command (the default) to instruct the
debugger not to stop when unaligned access occurs. (See also the catch
unaligned command.)
kill
Use the kill command to terminate the current program process and leave
the debugger running. When a process terminates, breakpoints and traces
previously set are retained. You can later rerun the program.
kps
Use the kps command to list all system processes. (This command is
valid for local kernel debugging only.)
list
list startline [,endline ]
list startline [:count]
list function
The list command displays source-code lines beginning with@ the source
line corresponding to the position of the program counter, the last
line listed if multiple list commands are issued, or the line number
specified as the first argument to the list command. Specify the exact
range of source-code lines by including either the endline or the
number of lines you want to display. The arguments can be expressions
that evaluate to integer values.
To display the source code for a particular function, enter the
function as an argument.
listobj
Use the listobj command to list all loaded objects, including the main
image and the shared libraries. For each object, the information listed
consists of the full object name (with pathname), the starting address
for the text, the size of the text region, and whether the symbol table
information has been read by the debugger.
load image_file [core_file]
unload process_id ,...
unload image_file
The load command loads an image file and optionally a core file. After
loading an image file, enter the run command to start program
execution.
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.
next [expression]
Use the next and the step commands to execute a line of source code.
When the next line to be executed contains a function call, the next
command executes the function being called and returns to the line
immediately after the function call. The step command steps into the
function and executes only the first line of the function.
For multithreaded applications, use these commands to step the current
thread while putting all other threads on hold.
If the optional expression argument is supplied, the debugger evaluates
the expression as a positive integer that specifies the number of times
to execute the command. The expression can be any expression that is
valid in the current context.
nexti [expression]
Use the stepi command and the nexti command to execute a machine
instruction. When the instruction contains a function call, the stepi
command steps into the function being called, and the nexti command
executes the function being called.
For multithreaded applications, use these commands to step the current
thread while putting all other threads on hold.
If the optional expression argument is supplied, the debugger evaluates
the expression as a positive integer that specifies the number of times
to execute the command. The expression can be any expression that is
valid in the current context.
map source directory directory1 directory2
Use the map source directory command to tell the Ladebug debugger that
the source files in directory directory1 are now to be found in
directory2.
See also show source directory and unmap source directory for
displaying and unsetting source directory mapping.
patch expression1 = expression2
Use the patch command to correct bad data or instructions in executable
disk files. The text, initialized data, or read-only data areas can be
patched. The bss segment, as well as stack and register locations,
cannot be patched because they do not exist on disk files.
Use this command exclusively when you need to change the on-disk
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.
playback input filename
Use the source command and the playback input command to execute
debugger commands contained within a file. (Note that you can also
execute debugger commands when you invoke the debugger by creating an
initialization file named .dbxinit. By default, the debugger searches
for this file during startup, first in the current directory; if it is
not there, the debugger searches your home directory for the file.)
Format commands as if they were entered at the debugger prompt.
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.
pop [number_of_frames]
The pop command removes one or more execution frames from the call
stack, terminating the actions of the called functions coresponding to
those frames immediately.
The optional argument is the number of execution frames to remove from
the call stack. If you do not specify the argument, one frame is
removed. If specified, the number must be a positive integer less than
or equal to the number of frames currently on the call stack.
print [expression ,...]
print @linenumber
The print command displays the current value of a variable or
expression that is visible in the current context, as defined by the
scope and visibility rules of the program language. The expression can
be any expression that is valid in the current context.
The print @ 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 last form of the print command.
Set the $usedynamictypes debugger variable to 1 to display dynamic
information; set it to 0 to display static information. The default is
dynamic.
Use printx, printd or printo to temporarily set the display radix to
hex, decimal or octal when printing.
printb [expression ,...]
This command is identical to print except that it displays the values
of the expressions in binary radix.
printd [expression ,...]
This command is identical to print except that it displays the values
of the expressions in decimal radix.
printenv [env_variable]
Displays the value of the specified environment variable. If none is
specified, the command displays the values of all environment
variables.
This command does not reflect the current debuggee's environment, but
the environment of any debuggees which might now be created with run or
rerun commands.
printf [format [,expression ,...]]
Use the printf command to format and display a complex structure. The
format argument is a string expression of characters and conversion
specifications, using the same format specifiers as the printf C
function. The printf command requires a running target program.
printi [expression ,...]
This command takes one or more numerical expressions and interprets
each one as an assembly instruction, printing out the instruction, and
its arguments when applicable.
printo [expression ,...]
This command is identical to print except that it displays the values
of the expressions in octal radix.
printregs
Use the printregs command to display the contents of all machine
registers for the current thread. Register values are given in both
decimal and hexadecimal, depending on the value of the $hexints
variable. The list of registers displayed by the debugger is machine
dependent.
printt [expression ,...]
This command takes one or more numerical expressions and interprets
each one as the number of seconds since the Epoch (00:00:00 UTC 1 Jan
1970).
printx [expression ,...]
This command is identical to print except that it displays values of
the expressions in hexdecimal radix.
process [process_id | image_file | debugger_variable]
Specify a specific process using the process ID number or the name of
the image. The Ladebug debugger sets the current process context to the
process ID or the process that runs the binary image. If there is more
than one process running the same binary image, the Ladebug debugger
warns you and leaves the process context unchanged. The debugger
variables $childprocess and $parentprocess can also be specified in
place of the process ID. (the Ladebug debugger automatically sets these
variables when an application forks a child process.)
quit
Use the quit command to end the debugging session and return to the
operating system prompt.
readsharedobj shared_object
Use the readsharedobj command to read in the symbol table information
for a specified shared object. This object must be a shared library or
loadable kernel module. The command can be used only when a debuggee
program is specified; that is, either the Ladebug debugger has been
invoked with it, or the debuggee program was loaded by the load
command.
record input [filename]
record output [filename]
record io [filename]
Use the record input command to save all the debugger commands to a
file. The commands in the file can be executed using the source command
or the playback input command.
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, output or both, enter unrecord input,
unrecord output, unrecord io respectively, or change the recording file
to /dev/null.
If no file is specifed, the Ladebug debugger will create a file with a
random file name in /tmp as the record file.
return [function]
Use the return command without an argument to continue execution of the
current function until it returns to its caller. If you include a
function name, execution continues until control is returned to the
specified function. The function must be active on the call stack.
run [program_arguments] [io_redirection]
rerun [program_arguments] [io_redirection]
Use the run and rerun commands to start program execution. Enter
program flags, options, and input and output redirections as arguments.
If the rerun command is specified without arguments, the arguments
entered with the previous run command are used.
If the last modification time and size of the binary file or any of the
shared objects used by the binary file have changed since the last run
command was issued, the Ladebug debugger 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.
Environment variables and ~-names in the program arguments are
evaluated in the same manner as in a command shell.
save snapshot
Use the save snapshot command to save the current state of the debuggee
process in a snapshot. By doing this, you can conveniently return to
that state at a later time as opposed to re-running the program and
re-entering the debugger command sequence that brought you to that
state. Conceptually, this feature is similar to the "undo" function in
text editors, except that with snapshots you control the granularity of
each undo.
Snapshots are numbered sequentially starting from 1.
See also clone snapshot, delete snapshot, and show snapshot.
set [variable = definition]
unset variable
To examine the definitions of all debugger variables, enter the set
command without arguments. (Use the print command to display the
definition of a single debugger variable.)
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 enable 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:
$aggregatedmsghistory
Controls the length of the aggregated message list. If set to the
default (0), the debugger records as many messages as the system
will allow.
$ascii
With the default value of 1, enables the print command to print
character-type data as ASCII characters 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, all printable ISO
Latin-1 characters are 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 in commands that take a
process ID as an argument. (The debugger 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.
$catchforkinfork
When set to 1, instructs the debugger to catch a fork as soon as
possible during the fork call, rather than waiting until the fork
call returns to the user's program. Requires $stopparentonfork or
$catchforks to be set to take effect. The default is 0.
$curevent
Set to the event number of the current event at the start of an
event, allowing its use within an expression or action of an event.
$curfile
Specifies the current source-code file.
$curfilepath
Specifies the full path used by the debugger to access the current
source-code file.
$curline
Specifies the current line in the source file.
$curpc
Specifies the current value of the Program Counter (PC). The $curpc
variable is used by the wi alias.
$curprocess
Specifies the pid of the current process being debugged.
$cursrcline
Specifies the line number of the last line of source code listed,
plus one.
$cursrcpc
Specifies the current value of the address being listed as machine
code. The $curpc variable is used by the li alias.
$curthread
Indicates the thread ID of the current thread within the current
process. You can change to a different thread by setting
$curthread.
$dbxouputformat
When set to 1, the result of the print command is formatted in a
manner similar to the one used by dbx. The default is 0.
$dbxuse
When set to 1, the use command replaces the use list with the new
items. When set to 0, the use command appends the new items to the
existing list. The default is 1.
$decints
When set to 1, all integers printed by the debugger are displayed
as decimal numbers. The default is 0.
$doverbosehelp
When set to 1, help messages will be verbose. When set to 0, help
messages will be terse. The default is 1.
$editline
With the default of 1, enables the command-line editing features.
For backward compatibility, you can set this variable to 0.
$eventecho
With the default of 1, echoes events (such as breakpoints) with
event numbers when executed.
$floatshrinking
If set to the default (1), the debugger prints binary floating
point numbers using the shortest possible decimal number. If set to
0, the debugger prints the decimal number which is the closest
representation in the number of decimal digits available of the
internal binary number.
$funcsig
With the default of 1, causes display of the function signature
when the breakpoint-hit message is printed. When set to 0, causes
only the function name to be displayed. The default is 1.
$giveladebughints
When set to 1, the debugger may give hints to remind the user of
possibly useful commands. 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 are 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
With the default of 1, specifies that structures will be printed
with added indentation to render them more readable.
$ladebugpid
Value of the pid for Ladebug itself.
$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.
$lasteventmade
Set to the event number of the most recently created event at the
time of the event's creation, allowing users to record event
numbers for use in scripts.
$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.
$memorymatchall
When set to non-zero, displays all memory matches in the specified
range. Otherwise, only the first memory match is displayed.
$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.
$page
Controls debugger output pagination. When set, the debugger
generated terminal output will be paginated. Default value is 1
(ON) for command-line interface and 0 (OFF) for the GUI.
$pagewindow
Defines the number of lines per output page. The default of 0
causes the debugger to query the terminal for the page size.
$parallel_aggregatordelay
Specifies the length of time that aggregators wait before they
aggregate and send messages down to the next level when not all the
expected messages have been received. The default is 50
milliseconds.
$parallel_branchingfactor
Specifies the factor used to build the n-ary tree and determine the
number of aggregators in the tree.
$parentprocess
Can be specified in place of the process ID in commands that take a
process ID as an argument. (The debugger 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).
$readtextfile
If set to non-zero, instructions are read from the text area of the
binary file rather than from the memory image.
$regstyle
Controls the format of register names during disassembly. Valid
settings are 0 = compiler names, 1 = hardware names, and 2 =
assembly names.
$repeatmode
With the default of 1, causes the debugger to repeat the previous
command if you press the Return key at the (ladebug) prompt.
$showlineonstartup
When set to 1, causes the debugger to show the first line of "main"
on startup. When set to 0, causes the line not to be shown. The
default is 1.
$showwelcomemsg
When set to 1, causes the debugger to show the welcome message on
startup. When set to 0, causes the welcome message not to be shown.
The default is 1.
$stackargs
With the default of 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.
$statusargs
With the default of 1, causes the values of arguments to be
included in the output of the status command and in the status-line
printed by default each time the target stops. When large or
complex values are passed by value, the output can be voluminous.
You can set $statusargs to 0 to suppress the output of argument
values. The default is 1.
$stepg0
With the default of 0, causes the debugger to step over calls to
routines that are compiled without symbol information. When set to
1, the debugger steps into these calls.
$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. (See also the $catchforks
description.) The default is 0.
$symbolsearchlimit
Specifies the maximum number of symbols that will be returned by
the whereis command for a regular expression search. The default
value is 100; a value of 0 indicates no limit.
$threadlevel
Enables the Ladebug debugger 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
another 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).
$usedynamictypes
With the default of 1, instructs the debugger to display dynamic
type information. When set to 0, static type information is
displayed. Output of the print, trace, tracei, and whatis commands
is affected.
$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.
setenv [env_variable [value]]
Sets the value of the specified environment variable. If no variable is
specified, the command displays values of all the environment
variables. If a variable is specified but no value is specified, the
variable is set to NULL.
This command does not change the environment of the current debuggee.
It is used to set the environment for any debuggees subsequently
created with run or rerun commands.
Note that export and setenv are synonyms.
sh command
Use the sh command to execute a Bourne shell command. Do not enclose
the shell command and its arguments in quotations. For example:
(ladebug) sh ls -l sample.c
show aggregated message [message_id_list]
show aggregated message all
show aggregated message
The first form of the command displays the aggregated messages in the
list whose message IDs match the numbers specified in the
message_id_list. The second form displays all the aggregated messages
in the list. The third form, where no message_id is specified,
displays the most recently added (newest) message.
show condition [condition_identifier_list]
show condition [condition_identifier_list] with state == wait
For DECthreads only: Use the show condition command to list information
about currently available DECthreads condition variables. If you
supply one or more condition identifiers, the debugger displays
information about the condition variables that you specify, provided
that the list matches the identity of currently available condition
variables. If you omit the condition variable specification, the
debugger displays information about all the condition variables
currently available.
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.
show mutex [mutex_identifier_list]
show mutex [mutex_identifier_list] with state == locked
For DECthreads only: Use the show mutex command to list information
about currently available mutexes. If you specify one or more mutex
identifiers, the debugger displays information about only those mutexes
you specified, provided that the list matches the identity of currently
available mutexes. If you omit the mutex identifier specification, the
debugger displays information about all mutexes currently available.
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.
show process
show process *
show process all
Use the show process command to display information for the current
process. The second and third forms of the command display information
for all processes.
show process set [debugvar_name]
show process set all
show process set
Use the show process set command to inspect the process set stored in a
debugger variable. If the set name is not specified, or if the all
specifier is given, the debugger will display all the process sets that
are currently stored in debugger variables.
show snapshot *
show snapshot all
show snapshot [integer [, integer]* ]
The first two forms of the show snapshot * command display all the
snapshots that have been saved from the current process. The last form
displays the snapshots specified. If no snapshots are specified, the
most recently saved existing snapshot is displayed.
See also save snapshot, clone snapshot, and delete snapshot.
show source directory [directory]
show all source directory [directory]
Use the show source directory command to display the source directory
mapping information of directory and its child directories. If
directory is not specified, the Ladebug debugger displays the mapping
information of all the source directories whose parent is not a source
directory. The command show all source directory is identical to show
source directory except that the mapping information of all the
descendants of directory is displayed.
See also map source directory and unmap source directory for setting
and unsetting source directory mapping.
show thread [thread_identifier_list]
show thread [thread_identifier_list] with state == ready
show thread [thread_identifier_list] with state == blocked
show thread [thread_identifier_list] with state == running
show thread [thread_identifier_list] with state == terminated
show thread [thread_identifier_list] with state == detached
show thread [thread_identifier_list] with state == stopped
Use the show thread command to list all the threads known to the
debugger. If you specify one or more thread identifiers, the debugger
displays information about the threads you specify, if the thread
matches what you specified in the list. If you omit a thread
specification, the debugger displays information for all threads.
Use the show thread command to list threads that have specific
characteristics, such as threads that are currently blocked. To
display lists of thread characteristics, use one of the alternate
syntaxes listed.
The valid state values for DECthreads are ready, blocked, running,
terminated, and detached.
The valid state values for native threads are stopped, running, and
terminated.
source filename
Use the source command and the playback input command to execute
debugger commands contained within a file. (Note that you can also
execute debugger commands when you invoke the debugger by creating an
initialization file named .dbxinit. By default, the debugger searches
for this file during startup, first in the current directory; if it is
not there, the debugger searches your home directory for the file.)
Format commands as if they were entered at the debugger prompt.
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.
status
The status command lists all breakpoints, tracepoints, and watchpoints,
the reference number associated with each, and whether they are
disabled. All settings are on a per-process basis.
step [expression]
Use the next and the step commands to execute a line of source code.
When the next line to be executed contains a function call, the next
command executes the function being called and returns to the line
immediately after the function call. The step command executes only
the first line of the function.
For multithreaded applications, use these commands to step the current
thread while putting all other threads on hold.
If the optional expression argument is supplied, the debugger evaluates
the expression as a positive integer that specifies the number of times
to execute the command. The expression can be any expression that is
valid in the current context.
stepi [expression]
Use the stepi command and the nexti command to execute a machine
instruction. When the instruction contains a function call, the stepi
command steps into the function being called, and the nexti command
executes the function being called.
For multithreaded applications, use these commands to step the current
thread while putting all other threads on hold.
If the optional expression argument is supplied, the debugger evaluates
the expression as a positive integer that specifies the number of times
to execute the command. The expression can be any expression that is
valid in the current context.
stop [quiet] detector [thread thread_identifier_list]
[if expression] [ { command [;...] } ]
Enter the stop command to create a breakpoints which suspends the
debuggee and executes the commands in the command list argument (if
given) when the specified detector is triggered and both thread and if
conditions (if given) evaluate to true. If quiet is specified, the
Ladebug debugger will suppress the status reporting message when the
breakpoint is hit.
detector can be one of the following:
at line_number
This detector is triggered on execution of the line.
in function
This detector is triggered on calls to the function.
in all function
This detector is triggered on calls to all the functions named
function.
pc address
This detector is triggered when PC == address.
watched_memory [access] [within function]
This detector is triggered on the specified access on the region of
memory specified by watched_memory. If within function is given,
the detector is triggered only when the access occurs in the
specified function.
watched_memory can be one of the following:
variable lvalue
This form specifies the variable lvalue.
memory start_address
This form specifies the 8-byte memory at start_address.
memory start_address, end_address
This form specifies the memory region from start_address to
end_address (inclusively).
memory start_address:size
This form specifies the memory region of size-bytes starting
from start_address.
access can be one of the following:
write
read
changed
This mode detects writes that change the contents of the
memory.
any This mode detects both read and write. If no access argument is
specified, write is assumed.
signal signal ,...
This detector is triggered on reception of any of the signals
specified.
unaligned
This detector is triggered on unaligned access.
every proc entry
This detector is triggered on every procedure call.
every instruction
This detector is triggered on every program counter change.
expression
If expression is a function name, then this detector is the same as
in expression. Otherwise, it is the same as at expression.
For example:
stop 57 if ($i == 10){ print var; set $i = 0; }
creates a reflex which, when the execution is at line 57 of the current
file and $i is equal to 10, stops the debuggee, prints the
content of the variable var and sets $i to zero.
Note: For C++, the following forms of function name are acceptable in
addition to the usual simple identifiers:
· [class::]class_or_function [(type_signature)]
· object . function
· object_pointer_expression -> function
To set a breakpoint in a specific version of an overloaded function,
either set $overloadmenu to 1, and 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 may be explicitly
specified.
stopi variable
stopi [variable] if expression
stopi [variable] at address [if expression]
Enter the stopi command with a variable to suspend execution when the
variable value changes.
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.
When a variable is specified in the stopi command, the debugger will
stop the application after each instruction to check the variable's
value. This will slow the application's execution considerably. The
same slowing will occur for the command stopi if expression without an
at clause.
If an address is specified with an at clause, the stopi command does
not cause a slow-down.
thread [thread_identifier]
Use the thread command to identify or set the current thread context.
If you supply a thread identifier, the debugger sets the current
context to the thread you specify. If you omit the thread
identification, the debugger displays the current thread context.
The debugger interprets the thread identifier as a DECthreads or kernel
thread identifier, depending on the value of the debugger variable
$threadlevel.
trace [variable] [if expression]
trace [variable] at linenumber [if expression]
trace [variable] in function [if expression]
expression]
trace [variable] [thread thread_identifier_list] [at linenumber] [if
trace [variable] [thread thread_identifier_list]
[in function] [if expression]
When you use the trace command without an argument, the debugger prints
a message, but does not suspend program execution when each function is
entered. Specify a variable to print a message when the variable value
changes. Specify if with an expression to print a message when an
expression evaluates to true. When you specify both a variable and an
expression, a message is printed only if the expression evaluates to
true and the variable has changed.
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.
For C++: Use the $usedynamictypes variable to control whether the
debugger displays static (value = 0) or dynamic (value = 1)
information. The default is dynamic.
tracei [variable] [if expression]
tracei [variable] at address [if expression]
tracei [variable] in function [if expression]
tracei [variable] [thread thread_identifier_list]
[at linenumber] [if expression]
tracei [variable] [thread thread_identifier_list]
[in function] [if expression]
When you use the tracei command, the debugger prints a message, but
does not suspend program execution. Specify a variable to print a
message when the variable value changes. Specify an expression to print
a message when an expression evaluates to true. When you specify both a
variable and an expression, a message is printed only if the expression
evaluates to true and the variable has changed.
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, debugger performance is affected.
In the following example, a breakpoint is set to print a message every
time the variable factor is modified:
(ladebug) tracei factor
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 threads
of the application.
For C++: Use the $usedynamictypes variable to control whether the
debugger displays static (value = 0) or dynamic (value = 1)
information. The default is dynamic.
unrecord input
unrecord output
unrecord io
Undoes the previous parallel record command, stopping recording.
unsetenv [env_variable]
Removes the specified environment variable. If no variable is
specified, all environment variables are removed.
This command has no effect on the environment of the current debuggee.
It changes the environment of any debuggees subsequently created with
run or rerun commands.
up [number]
Use the up command or the down command without an argument to change
the function scope to the function located one level up or down the
stack. Enter a number argument to change the function scope to the
function up or down the specified number of levels. If the number of
levels exceeds the number of active functions on the stack, the
debugger issues a warning message.
When the function scope changes, the debugger displays the source line
corresponding to the last point of execution in that function.
unmap source directory [directory]
Enter the unmap source directory command removes the mapping of
directory if there was one.
See also map source directory and show source directory for setting and
displaying source directory mapping.
use [directory ,...]
unuse [directory ,...]
unuse *
Enter the use command without an argument to list the directories the
debugger searches for source-code files. Specify a directory argument
to make source-code files in that directory available to the debugger.
(You can also use the ladebug command -I option to specify search
directories.) The debugger control variable $dbxuse effects the
semantics of this command.
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.
watch memory start-address
[, end_address | :size_expression]
[any | changed | read | write]
[thread id_list]
[in function]
[if expression]
[{command[;...]}]
watch variable variable
[any | changed | read | write]
[thread id_list]
[in function]
[if expression]
[{command[;...]}]
The watch command suspends program execution, prints the watchpoint
event, prints the instruction that accessed the watched memory,
displays old and new values, and prints the first line of source code
that will be executed when program execution continues. Write accesses
are detected by default.
Use the watch memory command to indicate the address or address range
to be watched. Addresses can be given in any base. If neither the
optional end_address nor size_expression arguments are specified, the
debugger defaults to a data size of 8 bytes. The size_expression
argument can be any expression that is valid in the current context and
language.
Use the watch variable command to indicate the variable to be watched.
A variable can be located in global memory or on a stack. To watch a
variable in a register, use the stopi variable command. Local variables
are defined only within a function scope. Setting watchpoints on local
variables is valid only when they are in scope. The variable must be a
variable name or other expression which can be used as a target of an
assignment in the current language.
To detect accesses other than default write access, use the any,
changed, or read options. The any option detects any access. The
changed option detects any change in the value of the contents of the
watched memory. The read option detects only read access.
Use the thread id_list option to suspend execution when access occurs
in a certain thread.
Use the in function option to suspend execution when access occurs in a
certain function.
Use the if expression option to suspend execution at a point at which
the expression is true.
Use the command option to specify a command to execute when a
watchpoint suspends execution. Commands must be enclosed in braces.
Separate multiple commands with semicolons.
whatis expression
The whatis command prints the type of the specified expression. The
expression can be any expression that follows the syntax, scope, and
visibility rules of the program language.
For C++:
whatis classname
whatis [classname::]member
whatis [classname::]function
whatis classname::classname
The first syntax form of the whatis command displays the class type.
The second syntax form displays the type of a member function or data
member. To display all versions of an overloaded function, use the
third syntax form. To use this command as a constructor only, use the
last syntax form.
Use the $usedynamictypes variable to control whether the debugger
displays static (value = 0) or dynamic (value = 1) information. The
default is dynamic.
Enter the when command to create a breakpoint which executes the
commands in the command list (if any) when the detector is triggered
and both thread and if conditions (if given) evaluate to true. The
difference between stop and when is that a breakpoint created using
stop suspends the execution when hit whereas one created using when
does not. See also the description for stop for details on how to
create a breakpoint.
when [quiet] [detector] [thread thread-identifier-list]
[ if expression] [{command[;...]}]
Enter the when command to create a breakpoint which executes the
commands in the command list (if any) when the detector is triggered
and both thread and if conditions (if given) evaluate to true. The
difference between stop and when is that a breakpoint created using
stop suspends the execution when hit whereas one created using when
does not.
See also the description for stop for details on how to create a
breakpoint.
wheni {command[;...]}
wheni if expression {command[;...]}
wheni at linenumber [if expression] {command[;...]}
wheni in function [if expression] {command[;...]}
wheni [thread thread_identifier_list] [at linenumber]
[if expression] {command[;...]}
wheni [thread thread_identifier_list] [in function]
[if expression] {command[;...]}
Use the wheni command to execute the specified command. (The wheni
command does not suspend program execution.) The debugger command must
be enclosed in braces. Separate multiple commands with semicolons.
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 syntax 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 can cause the application to slow considerably if it
is used in the form wheni if expression without an in clause, as that
will cause the debugger to stop the application after each instruction
is executed to check the expression's value.
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.
where [number]
where [number] thread [thread_identifier_list]
where [number] thread all
where [number] thread *
The where command displays the stack trace of currently active
functions for the current thread. The second form of the command
displays the stack traces of the specified threads. The third form and
the fourth form of the command are equivalent; they display the stack
traces of all threads.
Include the optional number argument to list that number of levels at
the top of the stack. (Each active function is designated by a number
that can be used as an argument to the func command. The top level on
the stack is 0; if you enter the command where 3, you will see levels
of 0, 1, and 2.) If you do not specify the number argument, you will
see all levels.
whereis expression
whereis "string"
The first form of the whereis command shows all declarations of the
expression. Each declaration is fully qualified with scope information.
If you are not sure how to spell a symbol, you can use the second form
of the whereis command to search the symbol table for the regular
expression represented by the quoted string. All symbols that match the
rules of the regular expression are displayed in ascending order.
which expression
The which command shows the fully qualified scope information for the
instance of the specified expression in the current scope. If
available to the debugger, the name of the source file containing the
function in which the expression is declared, the name of the function,
and the name of the expression are included.
The syntax of the output is "filename"`function`variable.
RESTRICTIONS
The maximum command-line length is 100,000 characters.
Alias commands cannot contain more than 56 arguments.
FILES
a.out Default object file name.
core Default core dump file name.
.dbxinit
Initialization file. By default, the debugger searches for this
file at startup, first in the current directory; if it is not
there, the debugger searches your home directory.
.ladebugrc
Pre-initialization file. By default, the debugger searches for this
file at startup, first in the current directory; if it is not
there, the debugger searches your home directory.
SEE ALSO
Commands: ada(1), c89(1), cc(1), cxx(1), cobol(1), dbx(1), f77(1), f90(1),
printf(1)
Functions: signal(3)
The Ladebug Web Page at http://www.compaq.com/products/software/ladebug/
|
Index for
Section 1 |
|
|
Alphabetical
listing for L |
|
 |
Top of
page |
|