unixdev.net


Switch to SpeakEasy.net DSL

The Modular Manual Browser

Home Page
Manual: (OSF1-V5.1-alpha)
Page:
Section:
Apropos / Subsearch:
optional field



ladebug(1)							   ladebug(1)



NAME

  ladebug - Invokes the	Ladebug	debugger

SYNOPSIS

  ladebug
   [-c file ]
   [-gui]
   [-i file ]
   [-I directory ]
   [-k]
   [-line serial_line]
   [-nosharedobjs]
   [-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 pro-
  grams	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 initializa-
	    tion 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 con-
	    nected 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 Lade-
	    bug	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.

  -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	quotes (" ").

  -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,	printf,	printregs, 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

  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

  startaddress , endaddress / mode

  startaddress / count mode


       You can display stored values as	character strings, machine instruc-
       tions, or decimal, octal, hexadecimal, or real numbers. Specify the
       address and the number of words or bytes	(count)	information in
       hexadecimal, octal, or decimal. The display mode	must be	specified
       along with the address range. The modes are:

       b    Print a byte in hexadecimal.

       c    Print a byte 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).

       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.

  Note that you	must enter a space between "count" and "mode" if the language
  of the program being debugged	is COBOL.

  # 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 expres-
       sion 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 func-
       tion as if you were calling it from within the program. If the func-
       tion 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	pro-
       cess 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	exe-
       cution until a breakpoint, a signal, an error, or the end of the	pro-
       gram 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	pro-
       gram 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 pro-
       cess * 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	dis-
       able all	command	or the disable * command to disable all	breakpoints,
       tracepoints, or watchpoints.

       The disabled breakpoint is displayed in response	to the status com-
       mand, 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 func-
       tion 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).

  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.

  func [function]

  func [integer]

       Use the func command without an argument	to display the current func-
       tion 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 pro-
       gram.

  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 func-
       tion 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 evalu-
       ates 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 evalu-
       ates 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	is now to be found in direc-
       tory2.

       See also	show source directory and unmap	source directory for display-
       ing and unsetting source	directory mapping.

  patch	expression1 = expression2

       Use the patch command to	correct	bad data or instructions in execut-
       able disk files.	The text, initialized data, or read-only data areas
       can be patched. The bss segment,	as well	as stack and register loca-
       tions, 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 expres-
       sion 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.

  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 vari-
       ables.

       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	func-
       tion.

  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 vari-
       able.  The list of registers displayed by the debugger is machine
       dependent.

  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 speci-
       fied 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 debug-
       gee 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_redirections]

       Use the run and rerun commands to start program execution. Enter	pro-
       gram 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 set-
       tings 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 debug-
       gee 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 granular-
       ity 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	vari-
       ables apply to all debugging processes.

       The debugger has	the following predefined variables:

       $ascii
	    With the default value of 1, enables the print command to print
	    character-type data	as ASCII characters, only when the bit value
	    is that of a printable 7-bit subset	ASCII character.  (Other bit
	    values are printed as octal	numbers.)  With	a value	of 0, 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. (the Ladebug
	    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 the expression 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.

       $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 charac-
	    ter	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 usu-
	    ally 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.

       $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 func-
	    tion. This variable	is useful when debugging languages whose pri-
	    mary function is called something other than main().

       $maxstrlen
	    Specifies the maximum number of characters to print	when the
	    value of a string is printed.  The default is 128.

       $octints
	    When set to	1, the debugger	prints all integers as octal numbers.
	    The	default	is 0.

       $overloadmenu
	    When debugging C++ programs	only, if this variable is set to 1, a
	    menu of overloaded functions is displayed so you can select	the
	    desired function from the list of type signatures of the func-
	    tion.  When	set to 0, no menu is displayed,	and you	must disambi-
	    guate overloaded functions by providing the	full type signature.
	    The	default	is 1.

       $page
	    Controls debugger output pagination.  When set, the	debugger gen-
	    erated terminal output will	be paginated.  Default value is	1
	    (ON) for command-line interface and	0 (OFF)	for the	GUI.

       $pagewindow
	    Determines the number of lines per page to be displayed when out-
	    put	pagination is turned on.  Default value	is 0 which means the
	    debugger dynamically adjusts the page size to the user's window
	    size.

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

       $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	out-
	    put	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 volumi-
	    nous.  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.

       $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 com-
	    mands 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	vari-
       ables.  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 condition [condition_identifier_list]

  show condition [condition_identifier_list] with state	== wait

       For DECthreads only:  Use the show condition command to list informa-
       tion about currently available DECthreads condition variables.  If you
       supply one or more condition identifiers, the debugger displays infor-
       mation about the	condition variables that you specify, provided that
       the list	matches	the identity of	currently available condition vari-
       ables.  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 informa-
       tion only for condition variables that have one or more threads wait-
       ing. 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 specifi-
       cation, 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 informa-
       tion for	all processes.

  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 direc-
       tory 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 des-
       cendants	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 specifi-
       cation, the debugger displays information for all threads.

       Use the show thread command to list threads that	have specific charac-
       teristics, 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 watch-
       points, 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 evalu-
       ates 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 evalu-
       ates 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:

       o at line_number
	 This detector is triggered on execution of the	line.

       o in function
	 This detector is triggered on calls to	the function.

       o in all	function
	 This detector is triggered on calls to	all the	functions
	 named function.

       o pc address
	 This detector is triggered when PC == address.

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

       o signal	signal ,...
	 This detector is triggered on reception of any	of the
	 signals specified.

       o unaligned
	 This detector is triggered on unaligned access.

       o every proc entry
	 This detector is triggered on every procedure call.

       o every instruction
	 This detector is triggered on every program counter change.

       o 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 speci-
       fied.

  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 expres-
       sion, execution suspends	only if	the specified expression evaluates to
       true and	the variable has changed.

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

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

  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	con-
       text to the thread you specify.	If you omit the	thread identifica-
       tion, the debugger displays the current thread context.

       The debugger interprets the thread identifier as	a DECthreads or	ker-
       nel 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]

  trace	[variable] [thread thread_identifier_list]
   [at linenumber] [if expression]

  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 mes-
       sage when an expression evaluates to true. When you specify both	a
       variable	and an expression, a message is	printed	only if	the expres-
       sion 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	mes-
       sage 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 exe-
       cuting 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 tra-
       cepoint 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) informa-
       tion.  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	function factorial is entered:

       (ladebug) tracei	factorial

       Use the tracei thread command to	set tracepoints	in specific threads.
       If you list one or more thread identifiers, the debugger	sets a tra-
       cepoint 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) informa-
       tion.  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 speci-
       fied, 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 direc-
       tory 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 direc-
       tory 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, on a	stack, or in a regis-
       ter.  Local variables are defined only within a function	scope.	Set-
       ting 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 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.

  when [quiet] detector	[thread	thread_identifier_list]
       [if expression] [{command[;...]}]

       Enter the when command to create	a breakpoint which executes the	com-
       mands in	th ecommand list (if any) when the detector is triggered and
       both thread and if conditions (if given)	evaluate to true. The differ-
       ence 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 encoun-
       tered.

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


       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 tra-
       cepoint 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 func-
       tions 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

       The whereis command shows all declarations of the expression. Each
       declaration is fully qualified with scope information.

  which	expression

       The which command shows the fully qualified scope information for the
       instance	of the specified expression in the current scope. If avail-
       able to the debugger, the name of the source file containing the	func-
       tion 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.

RELATED	INFORMATION

  ada(1), c89(1), cc(1), cxx(1), cobol(1), dbx(1), f77(1), f90(1), printf(1),
  signal(3).

  Ladebug Web Page at http://www.compaq.com/products/software/ladebug/