Adb Helpfile (taken from the man page)


"$" commands
------------

$b	display breakpoints in the current job.

$c	C stack backtrace. On Solbourne  systems,  it is  impossible 
	for adb to determine how many parameters were passed to a function.   
	The default that adb chooses in a $c command is to show the six  
	parameter registers. This can be overridden by appending a hexadecimal
	number to the $c command, specifying how many parameters to display.  
	For example, the $cf command will print 15 parameters for each
	function in the stack trace. If an address is given, then adb
	will use it as the stack pointer. For example, 0xffffcae0$c
	will start a backtrace using 0xffffcae0 as the stack pointer.

$d	Set the default radix to address  and  report the  new value.  
	Note: address is interpreted in the (old) current  radix.   
	Thus  '10$d' never changes the default radix.

$e	Print the names and values of external variables.

$h	Display this file

$i	Show which signals are passed to the  subprocess 
	with the minimum of adb interference.

$m	Print the address map.

$o	All integers input are regarded as octal.

$p	(Kernel debugging) Change the active processor number.
	The syntax is cpunumb$p. For example, 3$p will map
	in the process which was running on cpu 3. The processes
	stack and uarea can now be correctly interpreted.

$q	Exit from adb.

$r	Print the names and contents of  the  general CPU  registers, 
	and the instruction addressed by pc.

$s	Set the limit for symbol matches  to  address (default 255).

$t	Toggle printing of the prompt

$u	(Kernel core debugging). Change the mapping of the uarea to the
	specified process id. The syntax is process_id$u. The process 
	id must be entered in the current radix (in the default base
	16 radix, 75$u changes the mapping to process 0x75 == 117). 

$v	Print all non zero variables in octal.

$w	Set the page  width  for  output  to  address (default 80).

$x	Print the names and contents of the floating-point registers 
	0 through 15.

$X	Print the names  and  contents  of  floating-point registers 
	16 through 31.

$?	Print process ID, the  signal  which  stopped the subprocess, 
	and the registers.

$<filename      Read commands from the file filename.

<<filename	Similar to <, but can be used in  a  file  of
		commands without closing the file.

$>filename      Append output to filename, which  is  created




":" commands
------------

addr:b cmd	Set breakpoint at 'addr' and execute "cmd" when reached.

addr:d		Delete breakpoint from 'addr'

:r args		Run objectfile as a subprocess with arguments "args"

:cs             The subprocess is continued with signal s.

:ss             Single-step the subprocess with signal s.

:i              Add the signal specified by  address  to  the
		list  of  signals passed directly to the sub-process.

:t              Remove the signal specified by  address  from
		the list implicitly passed to the subprocess.

:i              Add the signal specified by  address  to  the
		list  of  signals passed directly to the sub-process

:t              Remove the signal specified by  address  from
		the list implicitly passed to the subprocess.

:k              Terminate the current subprocess, if any.


The Useful Format Modifiers
----------------
d		Print 2 bytes in decimal
D		Print 4 bytes in decimal
x		Print 2 bytes in hex
X		Print 4 bytes in hex
u		Print 2 bytes as unsigned decimal
U		Print 4 bytes as unsigned decimal
c		Print one byte as character
S		Print as string
a		Print value of dot in symbolic form
i		Print as machine instructions
f		Print as single precision floating point
F		Print as double precision floating point
W		Write four bytes to the specified location. For example,
			0xff128854/W 0xdeadbeef	
		writes the value 0xdeadbeef to location 0xff128854
		in the core file. The syntax is similar for writing to the
		text file.
