Unix/Linux Go Back    

Plan 9 - man page for acid (plan9 section 1)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

ACID(1) 										  ACID(1)

       acid - debugger

       acid [ -l libfile ] [ -wq ] [ -m machine ] [ pid ] [ textfile ]

       Acid is a programmable symbolic debugger.  It can inspect one or more processes that share
       an address space.  A program to be debugged may be specified by the process id of  a  run-
       ning or defunct process, or by the name of the program's text file (v.out by default).  At
       the prompt, acid will store function  definitions  or  print  the  value  of  expressions.
       Options are

       -w	Allow the textfile to be modified.

       -q	Don't print variable renamings at startup.

       -l library
		Load from library at startup; see below.

       -m machine
		Assume	instructions  are  for	the given CPU type (one of 3210, 386, 68020, 960,
		mips, mipsco, sparc, or sunsparc) instead of using the magic number to select the
		CPU type.

       At   startup,   acid   obtains	standard  function  definitions  from  the  library  file
       /lib/acid/port, architecture-dependent functions from  /lib/acid/$objtype,  user-specified
       functions  from	$home/lib/acid,  and further functions from -l files.  Definitions in any
       file may override previously defined functions.	If the function acidinit() is defined, it
       will be invoked after all modules have been loaded.  See 2c(1) and alef(1) for information
       about creating acid functions for examining data structures.

       Symbols of the program being debugged become integer variables whose values are addresses.
       Contents of addresses are obtained by indirection.  Local variables are qualified by func-
       tion name, for example main:argv.  When program symbols conflict with acid words,  distin-
       guishing  $  signs  are	prefixed.  Such renamings are reported at startup; option -q sup-
       presses them.

       Variable types (integer, float, list, string) and formats are inferred  from  assignments.
       Truth  values  false/true  are  attributed  to  zero/nonzero  integers  or  floats  and to
       empty/nonempty lists or strings.  Lists are sequences of expressions surrounded by {}  and
       separated by commas.

       Expressions  are  much  as  in C or Alef, but yield both a value and a format.  Alef-style
       casts to complex types are allowed.  Lists admit the following operators, with  subscripts
       counted from 0.

	      head list
	      tail list
	      append list, element
	      delete list, subscript

       Format  codes  are  the	same as in db(1).  Formats may be attached to (unary) expressions
       with \, e.g.  (32*7)\D.	There are two indirection operators, * to address a core image, @
       to address a text file.	The type and format of the result are determined by the format of
       the operand, whose type must be integer.

       Statements are

	      if expr then statement [ else statement ]
	      while expr do statement
	      loop expr, expr do statement
	      defn name(args) { statement }
	      local name
	      return expr
	      whatis [	name ]

       Here is a partial list of functions; see the manual for a complete list.

       stk()  Print a stack trace for current process.

       lstk() Print a stack trace with values of local variables.

       gpr()  Print general registers.	Registers can also be accessed by name, for example *R0.

       spr()  Print special registers such as program counter and stack pointer.

       fpr()  Print floating-point registers.

       regs() Same as spr();gpr().

	      Expression expr with format given by the character value of expression format.

	      Print 10 lines of source around the program address.

	      Get the source line for the program address into a window of a running  sam(1)  and
	      select it.

	      Print source line nearest to the program address.

	      List current source directories.

	      Add a source directory to the list.

	      Convert a string of the form sourcefile:linenumber to a machine address.

	      Convert a machine address to a source file name.

	      Convert a machine address to a source line number.

	      List breakpoints set in the current process.

	      Set a breakpoint in the current process at the given address.

	      Delete a breakpoint from the current process.

       cont() Continue execution of current process and wait for it to stop.

       step() Execute a single machine instruction in the current process.

       func() Step repeatedly until after a function return.

	      This replaceable function is called automatically when the given process stops.  It
	      normally prints the program counter and returns to the prompt.

	      Disassemble 30 machine instructions beginning at the given address.

	      Print a block of memory interpreted according to a string of format codes.

	      Like mem(), repeated for n consecutive blocks.

	      Print the values of the expressions.

	      Start a new process with arguments given as a string and halt at the first instruc-

       new()  Like newproc(), but take arguments (except argv[0]) from string variable progargs.

       win()  Like new(), but run the process in a separate window.

	      Start a stopped process.

	      Kill the given process.

	      Make the given process current.

	      Escape to the shell, rc(1), to execute the command string.

       Start to debug /bin/ls; set some breakpoints; run up to the first one:

	      % acid /bin/ls
	      /bin/ls: mips plan 9 executable
	      acid: new()
	      70094: system call  _main     ADD  $-0x14,R29
	      70094: breakpoint   main+0x4  MOVW R31,0x0(R29)
	      acid: pid
	      acid: argv0 = **main:argv\s
	      acid: whatis argv0
	      integer variable format s
	      acid: *argv0
	      acid: bpset(ls)
	      acid: cont()
	      70094: breakpoint  ls    ADD  $-0x16c8,R29

       Display elements of a linked list of structures:

	      complex Str { 'D' 0 val; 'X' 4 next; };
	      complex Str s;
	      s = *headstr;
	      while s != 0 do{
		   print(s.val, "\n");
		   s = s.next;

       Note the use of the .  operator instead of ->.

       Display an array of bytes declared in C as char array[].


       This  example  gives  array string format, then prints the string beginning at the address
       (in acid notation) *array.



       2a(1), 2c(1), 2l(1), alef(1), mk(1), db(1)
       Phil Winterbottom, ``Acid Manual''.

       At termination, kill commands are proposed for processes that are still active.

       There is no way to redirect the standard input and standard output of a new process.
       Source line selection near the beginning of a file may pick an adjacent file.
       With the extant stepping commands, one cannot step through instructions outside	the  text
       segment and it is hard to debug across process forks.

Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 07:46 PM.