ladebug - Invokes the Ladebug debugger
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]]
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 [Toc] [Back]
Specifies an initialization command file. The default initialization
file is 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. Activates the Ladebug debugger's graphical user
interface (GUI) as well as the command-line interface.
Specifies a pre-initialization command file. The default
pre-initialization file is 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. 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.
Enables local kernel debugging. Specifies the serial line
for remote kernel debugging. This must be used with -rp
kdebug. 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. 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.
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. 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 (" "). Enables remote
kernel debugging; for use with the kdebug kernel debugger.
Specifies the remote debug protocol. Currently only kdebug
is supported. -rp kdebug enables remote kernel debugging.
Specifies the terminal device for remote kernel debugging.
This must be used with -rp kdebug. Causes the Ladebug
debugger to print its version number and exit without
starting a debugging session. Specifies the program executable
file. If the file is not in the current directory,
specify the full pathname. Specifies the core file. If
the core file is not in the current directory, specify the
full pathname.
Entering Commands [Toc] [Back]
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 [Toc] [Back]
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 [Toc] [Back]
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: Print a byte in hexadecimal. Print a
byte as a character. Print a wide character as a
character. Print a short word in decimal. Print a
long word in decimal. Print a 32-bit (4 byte) decimal
display. Print a single-precision real number.
Print a double-precision real number. Disassemble
machine instructions. Print a long double
precision real number. Print a short word in
octal. Print a long word in octal. Print a 32-bit
(4 byte) octal display. Print a string of characters
(a C-style string that ends in null). Print a
null terminated string of wide characters. Print a
short word in unsigned decimal. Print a long word
in unsigned decimal. Print a 32-bit (4 byte)
unsigned decimal display. Print a short word in
hexadecimal. Print a long word in hexadecimal.
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.
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.)
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.
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.
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: assign attach stop at stop in cont
delete detach file func goto history status list
$cursrcpc/10i; set $cursrcpc=$cursrcpc+40 next
nexti print playback input show process all printregs
printf "%s", quit rerun record input record
output step next stepi nexti switch process where
show thread all (show thread when the kernel debugging
option is used) where thread all thread where
thread all list $curline-9:10 list $curline-5:10
list $curline-10:20 ($curpc-20)/10i watch memory
watch variable
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.
Use the attach command to connect to a running process.
Supply the process ID number; the image file
name is optional.
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.
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).
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.
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.
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 sideeffects
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.
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.
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).
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.
Use the delsharedobj command to remove the symbol
table information for the specified shared object
from the debugger.
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.
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).
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.
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.
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.
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).
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.
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.
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.
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.
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.
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.
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 taskoriented
list of commands.
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.
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.
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).
Enter the ignore unaligned command (the default) to
instruct the debugger not to stop when unaligned
access occurs. (See also the catch unaligned command.)
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.
Use the kps command to list all system processes.
(This command is valid for local kernel debugging
only.)
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 sourcecode
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
This command is identical to print except that it
displays the values of the expressions in binary
radix.
This command is identical to print except that it
displays the values of the expressions in decimal
radix.
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.
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.
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.
This command is identical to print except that it
displays the values of the expressions in octal
radix.
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.
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).
This command is identical to print except that it
displays values of the expressions in hexdecimal
radix.
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.)
Use the quit command to end the debugging session
and return to the operating system prompt.
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.
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.
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.
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.
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.
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:
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.
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. 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). 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.) When set to 1, instructs the debugger to
notify the user and stop the program when a program
execs. The default is 0. 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. 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. 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. Specifies the current
source-code file. Specifies the full path used by
the debugger to access the current source-code
file. Specifies the current line in the source
file. Specifies the current value of the Program
Counter (PC). The $curpc variable is used by the wi
alias. Specifies the pid of the current process
being debugged. Specifies the line number of the
last line of source code listed, plus one. Specifies
the current value of the address being listed
as machine code. The $curpc variable is used by the
li alias. Indicates the thread ID of the current
thread within the current process. You can change
to a different thread by setting $curthread. 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. 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. When set to 1,
all integers printed by the debugger are displayed
as decimal numbers. The default is 0. When set to
1, help messages will be verbose. When set to 0,
help messages will be terse. The default is 1.
With the default of 1, enables the command-line
editing features. For backward compatibility, you
can set this variable to 0. With the default of 1,
echoes events (such as breakpoints) with event numbers
when executed. 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.
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. When set
to 1, the debugger may give hints to remind the
user of possibly useful commands. The default is
1. 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. When set to 1, all integers are displayed as
hexadecimal numbers. The default is 0. Specifies
the number of previously input commands listed in
response to the history command. The default is 20.
With the default of 1, specifies that structures
will be printed with added indentation to render
them more readable. Value of the pid for Ladebug
itself. 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. 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. Specifies how
many lines the list command displays. The default
is 20. 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(). Specifies
the maximum number of characters to print when
the value of a string is printed. The default is
128. When set to non-zero, displays all memory
matches in the specified range. Otherwise, only the
first memory match is displayed. When set to 1,
the debugger prints all integers as octal numbers.
The default is 0. 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. 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.
Defines the number of lines per output page. The
default of 0 causes the debugger to query the terminal
for the page size. 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. Specifies the factor
used to build the n-ary tree and determine the number
of aggregators in the tree. 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.) Indicates the process ID of the
current process. Only for use in kernel debugging
(either local or remote). 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.
Specifies the debugger prompt. The default is
(ladebug). If set to non-zero, instructions are
read from the text area of the binary file rather
than from the memory image. Controls the format of
register names during disassembly. Valid settings
are 0 = compiler names, 1 = hardware names, and 2 =
assembly names. With the default of 1, causes the
debugger to repeat the previous command if you
press the Return key at the (ladebug) prompt. 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. 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.
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. 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. 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. 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. 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. 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.
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". 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). 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. 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.
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.
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
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.
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.
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.
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.
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.
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.
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 s
|
