ladebug man page on Tru64

Man page or keyword search:  
man Server   12896 pages
apropos Keyword Search (all sections)
Output format
Tru64 logo
[printable version]

ladebug(1)							    ladebug(1)

NAME
       ladebug - Invokes the Ladebug debugger

SYNOPSIS
       ladebug
	  [-c file]
	  [-gui]
	  [-i file]
	  [-I directory]
	  [-k]
	  [-line serial_line]
	  [-nosharedobjs]
	  [-parallel]
	  [-pid process_id [executable_file]]
	  [-prompt string]
	  [-remote]
	  [-rp remote_debug_protocol]
	  [-tty terminal_device]
	  [-V]
	  [executable_file [core_file]]

DESCRIPTION
       The  Ladebug  debugger  is  a symbolic source code debugger that debugs
       programs compiled by the DEC C, ACC, DEC C++, DEC Ada, DEC  COBOL,  DEC
       Fortran 90, and DEC Fortran 77 compilers.  For full source-level debug‐
       ging, compile the source code with the compiler	option	that  includes
       the symbol table information in the compiled executable file.

   Command-Line Options and Parameters
       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	 $sto‐
       ponattach  =  1"	 will  have  taken effect when the connection is made.
       Specifies the directory containing the source code for the target  pro‐
       gram,  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 readshare‐
       dobj command to read in the symbol table information  for  a  specified
       object.	 For Ladebug Version 67, enables parallel debugging for appli‐
       cations 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 option‐
       ally  also specify the binary file for that process. This option cannot
       be used with any remote or kernel debugging flags.  Specifies a	debug‐
       ger 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.  Cur‐
       rently  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 cur‐
       rent directory, specify the full pathname.  Specifies the core file. If
       the  core  file is not in the current directory, specify the full path‐
       name.

   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 charac‐
       ters.

       In Ladebug debugger commands, the words thread, in, at, state, if, pol‐
       icy,  priority, and with are command language keywords and must be sur‐
       rounded by parentheses in expressions that use  them  as	 variables  or
       type names.

   Task-related Command Sets
       The  following  section	lists  the  Ladebug debugger commands in task-
       related sets:

       Starting and stopping programs in the debugger: attach,	detach,	 kill,
       load, quit, rerun, run, unload For examples, enter help start.

       Stopping	 your  program at specific locations: delete, disable, enable,
       status, stop, stopi, when, wheni For examples, enter help breakpoint.

       Controlling the execution of your program:  call,  cont,	 conti,	 goto,
       next, nexti, return, step, stepi For examples, enter help execution.

       Saving  the  current  state of the debuggee process in a snapshot: save
       snapshot, clone snapshot, delete snapshot, show snapshot For  examples,
       enter help snapshot.

       Reading	and  writing  memory,  variables, and registers: assign, dump,
       examine_address, print,	printb,	 printf,  printi,  printregs,  printt,
       search_memory,  trace, tracei, watch For examples, enter help variable,
       help memory, or help register.

       Looking at the call stack: down, pop, up,  where	 For  examples,	 enter
       help stack.

       Showing the source for the program: /, ?, file, edit, list, unuse, use,
       map source directory, unmap source directory, show source directory For
       examples, enter help listing.

       Examining  or  changing	the  current scope under investigation: class,
       down, file, func, process, thread

       Manipulating processes: attach, detach, kill, process, show process

       Manipulating threads and thread-specific objects: show condition,  show
       mutex, show thread, thread

       Learning specifics about program variables: whatis, whereis, which

       Manipulating shared objects: delsharedobj, listobj, readsharedobj

       Controlling signal handling: catch, ignore

       Parallel	 debugging  commands: focus, show process set, show aggregated
       message, expand aggregated message

       Changing or understanding your Ladebug environment: alias,  set,	 help,
       unalias,	 unset	For  a complete list of debugger variables, enter help
       $variable.

       Changing or showing the current system environment:  export,  printenv,
       setenv, sh, unsetenv

       Logging	the  results of Ladebug debugger commands and replaying a log:
       #, playback, record, unrecord, source

       Recalling previously-used commands: !, history

       Debugging UNIX kernels: kps, patch There are also a  number  of	kernel
       debugging  command  aliases  such  as tlist and tstack available. Enter
       alias for a complete list of command aliases.

   Command Descriptions

	      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 posi‐
	      tive 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 speci‐
	      fying mode. If mode is not specified, the mode used in the  pre‐
	      vious  /	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-preci‐
	      sion real number.	 Print a double-precision real number.	Disas‐
	      semble 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 com‐
	      pares 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 defi‐
	      nition. 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, speci‐
	      fied with backslashes before the quotation marks, as in the fol‐
	      lowing example:

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

	      (ladebug) alias x

	      x		set $lang="C++"

	      Invoke the alias by entering the alias name, including any argu‐
	      ments 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	refer‐
	      ence  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 func‐
	      tion 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	 func‐
	      tions and calls the function you specify.

	      Enter the catch command without an argument to see which operat‐
	      ing 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 side-effects to cloning a snapshot. First, the snapshots  in
	      the future of the cloned snapshot are deleted. For example, sup‐
	      pose four snapshots are saved from a process.  Cloning the  sec‐
	      ond  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 automati‐
	      cally repeat the command count times. Specify a signal parameter
	      value to send an operating system signal to the program continu‐
	      ing execution. Specify the linenumber argument to	 halt  program
	      execution when that line number is reached. Specify the in-func‐
	      tion 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 exe‐
	      cution 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 sig‐
	      nal 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	 func‐
	      tion 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 func‐
	      tions bearing that name from which to choose.

	      The form of the optional function argument must be a valid func‐
	      tion name.

	      Enter the delete command followed by the number or numbers asso‐
	      ciated with a breakpoint, trace, or watch (as listed by the sta‐
	      tus  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 informa‐
	      tion for the specified shared object from the debugger.

	      Use the detach command with process IDs to detach from the spec‐
	      ified 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 watch‐
	      point.   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 func‐
	      tion 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 mes‐
	      sage.

	      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 parame‐
	      ters and local variables in an active function, specify it as an
	      argument.

	      Enter  the  dump.	 command (include the dot) to list the parame‐
	      ters 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 asso‐
	      ciated with a breakpoint, trace, or watch (as listed by the sta‐
	      tus 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	watch‐
	      points.

	      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 speci‐
	      fied 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  exe‐
	      cuted,  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 cur‐
	      rently active on the stack, specify either the name of the func‐
	      tion  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 dis‐
	      play a task-oriented list of commands.

	      Enter the history command without an argument to display	previ‐
	      ously  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  expres‐
	      sion 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	 oper‐
	      ating  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  source-code	 lines
	      by  including either the endline or the number of lines you want
	      to display. The arguments can be expressions  that  evaluate  to
	      integer values.

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

	      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	 path‐
	      name),  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 pro‐
	      gram 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 debug‐
	      ger 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 per‐
	      formed 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 debug‐
	      ger 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 posi‐
	      tive integer less than or equal to the  number  of  frames  cur‐
	      rently 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 num‐
	      ber 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  mem‐
	      bers  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 envi‐
	      ronment variables.

	      This command does not reflect the	 current  debuggee's  environ‐
	      ment,  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	struc‐
	      ture.  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	inter‐
	      prets  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 debug‐
	      ger is machine dependent.

	      This  command takes one or more numerical expressions and inter‐
	      prets 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 val‐
	      ues 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 infor‐
	      mation 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 automati‐
	      cally 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	conve‐
	      niently  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 environ‐
	      ment 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  pre‐
	      defined  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 charac‐
	      ters.  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  com‐
	      mands  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 cur‐
	      rent 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.	Speci‐
	      fies  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 dec‐
	      imal 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	repre‐
	      sentation	 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 dis‐
	      played.  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 com‐
	      mand.  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 corre‐
	      sponding 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().	Speci‐
	      fies 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 dis‐
	      ambiguate overloaded functions by providing the full type signa‐
	      ture.  The  default  is 1.  Controls debugger output pagination.
	      When set, the debugger generated terminal output will  be	 pagi‐
	      nated.  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  automati‐
	      cally  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, instruc‐
	      tions 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 val‐
	      ues  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 volumi‐
	      nous.  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 com‐
	      piled 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 comple‐
	      tion; 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  dis‐
	      played.  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 vari‐
	      ables.  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 cur‐
	      rently  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 informa‐
	      tion 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  informa‐
	      tion 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 cur‐
	      rent  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 vari‐
	      ables.

	      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 dis‐
	      played.

	      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 direc‐
	      tories. If directory is not specified, the Ladebug debugger dis‐
	      plays  the  mapping  information	of  all the source directories
	      whose parent is not a source directory.  The  command  show  all
	      source  directory	 is  identical to show source directory except
	      that the mapping information of all the descendants of directory
	      is displayed.

	      See  also	 map  source  directory and unmap source directory for
	      setting and unsetting source directory mapping.

	      Use the show thread command to list all the threads known to the
	      debugger.	 If  you  specify  one or more thread identifiers, the
	      debugger displays information about the threads you specify,  if
	      the thread matches what you specified in the list. If you omit a
	      thread specification, the debugger displays information for  all
	      threads.

	      Use  the	show thread command to list threads that have specific
	      characteristics, such as threads that are currently blocked.  To
	      display  lists  of thread characteristics, use one of the alter‐
	      nate syntaxes listed.

	      The valid state values for DECthreads are ready,	blocked,  run‐
	      ning, terminated, and detached.

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

	      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 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 debug‐
	      ger 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  status  command  lists  all	breakpoints,  tracepoints, and
	      watchpoints, the reference  number  associated  with  each,  and
	      whether  they  are  disabled.  All settings are on a per-process
	      basis.

	      Use the next and the step commands to execute a line  of	source
	      code.  When  the	next  line  to be executed contains a function
	      call, the next command executes the function  being  called  and
	      returns  to  the	line immediately after the function call.  The
	      step command executes only the first line of the function.

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

	      If  the  optional	 expression argument is supplied, the debugger
	      evaluates the expression as a positive  integer  that  specifies
	      the  number  of times to execute the command. The expression can
	      be any expression that is valid in the current context.

	      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.
			   [if expression]  [ { command	 [;...] } ]

	      Enter  the  stop	command to create a breakpoints which suspends
	      the debuggee and executes the commands in the command list argu‐
	      ment  (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 sta‐
	      tus reporting message when the breakpoint is hit.

	      detector can be one of the following: This detector is triggered
	      on  execution  of the line.  This detector is triggered on calls
	      to the function.	This detector is triggered on calls to all the
	      functions named function.	 This detector is triggered when PC ==
	      address.	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: This form  specifies
	      the  variable  lvalue.  This form specifies the 8-byte memory at
	      start_address.  This  form  specifies  the  memory  region  from
	      start_address to end_address (inclusively).  This form specifies
	      the memory region of size-bytes starting from start_address.

	      access can be one of the following:  This	 mode  detects	writes
	      that  change the contents of the memory.	This mode detects both
	      read and write. If no access argument  is	 specified,  write  is
	      assumed.	 This detector is triggered on reception of any of the
	      signals specified.  This	detector  is  triggered	 on  unaligned
	      access.	This  detector	is  triggered on every procedure call.
	      This detector is triggered on every program counter change.   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  accept‐
	      able    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 func‐
	      tion, either set $overloadmenu to 1, and enter the command  stop
	      in  function, and choose the appropriate function from the menu,
	      or specify the function and the type signature as	 arguments  to
	      the  command. If the overloaded function has no parameters, void
	      may be explicitly specified.

	      Enter the stopi command with a  variable	to  suspend  execution
	      when the variable value changes.

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

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

	      When  a variable is specified in the stopi command, the debugger
	      will stop the application after each instruction	to  check  the
	      variable's  value.  This	will  slow the application's execution
	      considerably.  The same slowing will occur for the command stopi
	      if expression without an at clause.

	      If  an address is specified with an at clause, the stopi command
	      does not cause a slow-down.

	      Use the thread command to identify or  set  the  current	thread
	      context.	If  you	 supply a thread identifier, the debugger sets
	      the current context to the thread you specify. If you  omit  the
	      thread  identification, the debugger displays the current thread
	      context.

	      The debugger interprets the thread identifier as a DECthreads or
	      kernel thread identifier, depending on the value of the debugger
	      variable $threadlevel.
	      [in function] [if expression]

	      When you use the trace command without an argument, the debugger
	      prints  a	 message,  but does not suspend program execution when
	      each function is entered. Specify a variable to print a  message
	      when  the	 variable value changes. Specify if with an expression
	      to print a message when an expression evaluates  to  true.  When
	      you  specify  both  a  variable  and an expression, a message is
	      printed only if the expression evaluates to true and  the	 vari‐
	      able 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 vari‐
	      able  and	 an expression, a message is printed only if the vari‐
	      able has changed and the expression evaluates to true  when  the
	      line or function is encountered.

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

	      (ladebug) trace f in main

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

	      For C++: Use the $usedynamictypes variable  to  control  whether
	      the  debugger displays static (value = 0) or dynamic (value = 1)
	      information.  The default is dynamic.
	      [at linenumber] [if expression]
	      [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 mes‐
	      sage 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 expres‐
	      sion, a message is printed only if the expression	 evaluates  to
	      true when the address or function is encountered. If you specify
	      both a variable and an expression, a message is printed only  if
	      the  variable  has  changed and the expression evaluates to true
	      when the address or function is encountered.

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

	      In the following example, a breakpoint is set to print a message
	      every time the variable factor is modified:

	      (ladebug) tracei factor

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

	      For C++: Use the $usedynamictypes variable  to  control  whether
	      the  debugger displays static (value = 0) or dynamic (value = 1)
	      information.  The default is dynamic.

	      Undoes the previous parallel record command, stopping recording.

	      Removes  the  specified  environment variable. If no variable is
	      specified, all environment variables are removed.

	      This command has no effect on the	 environment  of  the  current
	      debuggee.	  It  changes  the environment of any debuggees subse‐
	      quently created with run or rerun commands.

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

	      Enter  the unmap source directory command removes the mapping of
	      directory if there was one.

	      See also map source directory and show source directory for set‐
	      ting and displaying source directory mapping.

	      Enter  the  use command without an argument to list the directo‐
	      ries 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  com‐
	      mand -I option to specify search directories.) The debugger con‐
	      trol variable $dbxuse effects the semantics of this command.

	      Enter the unuse command without an argument to  set  the	search
	      list  to the default: the home directory, the current directory,
	      and the directory containing the executable  file.  Include  the
	      name  of	a  directory  to  remove  it from the search list. The
	      asterisk (*) argument removes all directories  from  the	search
	      list.
		   [, end_address | :size_expression]
		      [any | changed | read | write]
		      [thread id_list]
		      [in function]
		      [if expression]
		      [{command[;...]}]

		      [any | changed | read | write]
		      [thread id_list]
		      [in function]
		      [if expression]
		      [{command[;...]}]

	      The  watch command suspends program execution, prints the watch‐
	      point 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 con‐
	      tinues. 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 nei‐
	      ther  the optional end_address nor size_expression arguments are
	      specified, the debugger defaults to a data size of 8 bytes.  The
	      size_expression  argument can be any expression that is valid in
	      the current context and language.

	      Use the watch variable command to indicate the  variable	to  be
	      watched.	A  variable  can  be  located in global memory or on a
	      stack. To watch a variable in a register, use the stopi variable
	      command.	Local  variables  are  defined	only within a function
	      scope. Setting watchpoints on local variables is valid only when
	      they are in scope. The variable must be a variable name or other
	      expression which can be used as a target of an assignment in the
	      current language.

	      To detect accesses other than default write access, use the any,
	      changed, or read options. The any option detects any access. The
	      changed  option  detects any change in the value of the contents
	      of the watched memory. The read option detects only read access.

	      Use the thread id_list option to suspend execution  when	access
	      occurs in a certain thread.

	      Use  the	in  function  option  to suspend execution when access
	      occurs in a certain function.

	      Use the if expression option to suspend execution at a point  at
	      which the expression is true.

	      Use  the	command	 option to specify a command to execute when a
	      watchpoint suspends execution.  Commands	must  be  enclosed  in
	      braces. Separate multiple commands with semicolons.

	      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 func‐
	      tion  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 debug‐
	      ger displays static (value = 0) or dynamic (value = 1)  informa‐
	      tion.  The default is dynamic.

	      Enter the when command to create a breakpoint which executes the
	      commands in the command list (if any) when the detector is trig‐
	      gered  and  both thread and if conditions (if given) evaluate to
	      true. The difference between stop and when is that a  breakpoint
	      created  using  stop suspends the execution when hit whereas one
	      created using when does not. See also the description  for  stop
	      for details on how to create a breakpoint.
	      [ if expression] [{command[;...]}]

	      Enter the when command to create a breakpoint which executes the
	      commands in the command list (if any) when the detector is trig‐
	      gered  and  both thread and if conditions (if given) evaluate to
	      true. The difference between stop and when is that a  breakpoint
	      created  using  stop suspends the execution when hit whereas one
	      created using when does not.

	      See also the description for stop for details on how to create a
	      breakpoint.
	       [if expression] {command[;...]}
	      [if expression] {command[;...]}

	      Use  the	wheni  command to execute the specified command.  (The
	      wheni command does not suspend program execution.)  The debugger
	      command  must  be enclosed in braces. Separate multiple commands
	      with semicolons.

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

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

	      The wheni command can cause the application to slow considerably
	      if  it  is  used	in  the form wheni if expression without an in
	      clause, as that will cause the debugger to stop the  application
	      after  each  instruction	is  executed to check the expression's
	      value.

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

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

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

	      The  where  command displays the stack trace of currently active
	      functions for the current thread. The second form of the command
	      displays	the  stack  traces of the specified threads. The third
	      form and the fourth form of the  command	are  equivalent;  they
	      display the stack traces of all threads.

	      Include the optional number argument to list that number of lev‐
	      els 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.

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

	      If you are not sure how to spell a symbol, you can use the  sec‐
	      ond  form	 of the whereis command to search the symbol table for
	      the regular expression represented by  the  quoted  string.  All
	      symbols  that match the rules of the regular expression are dis‐
	      played in ascending order.

	      The which command shows the fully	 qualified  scope  information
	      for  the	instance  of  the  specified expression in the current
	      scope.  If available to the debugger, the	 name  of  the	source
	      file   containing	 the  function	in  which  the	expression  is
	      declared, the name of the function, and the name of the  expres‐
	      sion 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
       Default object file name.  Default core dump file name.	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.  Pre-initialization file. By default, the
       debugger searches for this file at startup, first in the current direc‐
       tory; if it is not there, the debugger searches your home directory.

SEE ALSO
       Commands: ada(1), c89(1),  cc(1),  cxx(1),  cobol(1),  dbx(1),  f77(1),
       f90(1), printf(1)

       Functions: signal(3)

       The  Ladebug  Web Page at http://www.compaq.com/products/software/lade‐
       bug/

								    ladebug(1)
[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Tru64

List of man pages available for Tru64

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net