adb(1)

The value of dot.

The value of dot increased by the current increment.

The value of dot decreased by the current decrement.

The last address typed.

A number. The prefix 0 (zero) forces interpretation in octal radix; the prefixes 0d and 0D force interpretation in decimal radix; the prefixes 0x and 0X force interpretation in hexadecimal radix. Thus 020 = 0d16 = 0x10 = sixteen. If no prefix appears, the default radix is used; see the $d command. The radix is initialized to the base used in the assembly language for the processor involved. Note that a hexadecimal number whose most significant digit would otherwise be an alphabetic character must have a 0x (or 0X) prefix.

A 32-bit floating-point number.

The ASCII value of up to 4 characters. A backslash (\) can be used to escape a single quote (').

name can have the value of either a variable or a register. adb maintains a number of variables named by single letters or digits; see Variables below. If name is a register, the value of the register is obtained from the CORE_PROC segment in corfil (before the subprocess is initiated) or from the user area of the subprocess. Register names are implementation dependent; see the $r command.

A symbol is a sequence of uppercase or lowercase letters, underscores, or digits, not starting with a digit. A backslash (\) can be used to escape other characters. The value of the symbol is taken from the symbol table in objfil. An initial underscore (_) is prefixed to symbol, if needed.

If the compiler prefixes _ to an external symbol, it may be necessary to cite this name to distinguish it from a symbol generated in assembly language.

The value of the expression exp.

The contents of the location addressed by exp in corfil.

The contents of the location addressed by exp in objfil.

Integer negation.

Bitwise complement.

Integer addition.

Integer subtraction.

Integer multiplication.

Integer division.

Bitwise conjunction.

Bitwise disjunction.

e1 rounded up to the next multiple of e2.

Locations starting at address in objfil are printed according to the format f. dot is incremented by the sum of the increments for each format letter. If a subprocess has been initiated, address references a location in the address space of the subprocess instead of objfil.

Locations starting at address in corfil are printed according to the format f and dot is increased like ?. If a subprocess has been initiated, address refers to a location in the address space of the subprocess instead of corfil.

The value of address is printed in the styles indicated by the format f. (For i format ? is printed for the parts of the instruction that refer to subsequent words.)

Print 2 bytes in octal. All octal numbers output by adb are preceded by 0.

Print 4 bytes in octal.

Print 2 bytes in signed octal.

Print 4 bytes in signed octal.

Print 2 bytes in decimal.

Print 4 bytes in decimal.

Print 2 bytes in hexadecimal.

Print 4 bytes in hexadecimal.

Print 2 bytes as an unsigned decimal number.

Print 4 bytes as an unsigned decimal number.

Print the 32 bit value as a floating point number.

Print double floating point.

Print the addressed byte in hexadecimal.

Print the addressed byte in octal.

Print the addressed character (the sign bit is ignored).

Print the addressed character using the following escape convention. First, the sign bit is discarded, then character values 000 to 040 are printed as @ followed by the corresponding character in the range 0100 to 0140. The character @ is printed as @@.

Print the addressed characters until a zero character is reached.

Print a string using the @ escape convention. The value n is the length of the string including its zero terminator.

Print 4 bytes in date format (see ctime(3C)).

Print as machine instructions. The value of n is the number of bytes occupied by the instruction.

Print the value of dot in symbolic form.

Print the addressed value in symbolic form. The value of n is a machine-dependent constant.

When preceded by an integer, moves to the next appropriate tab stop. For example, 8t moves to the next 8-space tab stop.

Print a space.

Print a new-line character.

Print the enclosed string.

dot is decreased by the current increment. Nothing is printed.

dot is increased by 1. Nothing is printed.

dot is decreased by 1. Nothing is printed.

Repeat the previous command with a count of 1. The value of dot continues from the end of the previous format, unlike a [?/] command with no address, which repeats the previous address value. New-line can also be used to repeat a :s or :c command; however, any arguments to the previous command are lost.

Words starting at dot are masked with mask and compared with value until a match is found. If L is used, adb looks to match 4 bytes at a time instead of 2. If no match is found, dot is left unchanged; otherwise dot is set to the matched location. If mask is omitted -1 is used.

Write the 2-byte value into the addressed location. If the command is W, write 4 bytes. Odd addresses are not allowed when writing to the subprocess address space.

Toggle the address mapping of corfil between the initial map set up for a valid core file and the default mapping pair which the user can modify with /m. If the corfil was invalid, only the default mapping is available.

Record new values for (b1, e1, f1). If fewer than three expressions are given, the remaining map parameters are left unchanged. If the ? or / is followed by *, the second segment (b2, e2, f2) of the mapping is changed. If the list is terminated by ? or /, the file (objfil or corfil, respectively) is used for subsequent requests. (For example, /m? causes / to refer to objfil.) A /m command switches the corfil mapping to the default mapping pair. For a valid core file, the =m command can be used to switch back to the initial mapping.

Assign dot to the variable or register named.

Call a shell to read the remainder of the line following !.

Read commands from the file f. If this command is executed in a file, further commands in the file are not seen. If a count is given, and is zero, the command is ignored. The value of the count is placed in variable 9 before the first command in f is executed.

Similar to $< except it can be used in a file of commands without causing the file to be closed. Variable 9 is saved when the command executes and is restored when it completes. Only five $<< files can be open at once.

Send output to the file f, which is created if it does not already exist.

Print the general registers and the instruction addressed by the process counter. dot is set to the process counter contents.

Print the floating-point registers.

Print all breakpoints and their associated counts and commands.

C stack backtrace. If address is given, it is taken as the address of the current frame (instead of the normal stack frame pointer). If count is given, only the first count frames are printed.

The names and values of external variables are printed.

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

Set the limit for symbol matches to address. The default is system dependent.

The default for all integers input is octal.

Set the default radix to address and report the new value. Note that address is interpreted in the (old) current radix. Thus 10$d never changes the default radix. To make decimal the default radix, use 0d10$d.

The default for all integers input is hexadecimal.

Exit from adb.

Print all non-zero variables in the current radix.

Print the address map. This includes both the initial and default maps for a valid corfil with an indication of which is currently active.

Print the process id and register values.

Print a list of signals and how they are handled. See :z for information on changing signal handling.

Set breakpoint at address. The breakpoint is executed count-1 times before causing a stop. Each time the breakpoint is encountered, the command c is executed. If this command sets dot to zero, the breakpoint causes a stop.

Delete breakpoint at address. :d* deletes all breakpoints.

Run objfil as a subprocess. If address is given explicitly, the program is entered at this point; otherwise the program is entered at its standard entry point. The value count specifies how many breakpoints are ignored before stopping. Arguments to the subprocess may be supplied on the same line as the command. An argument starting with < or > causes the standard input or output to be established for the command. All signals are turned on when entering the subprocess.

Set up a subprocess as in :r; no instructions are executed.

Continue the subprocess with signal s (see signal(5)). If address is given, the subprocess continues at this address. If no signal is specified, the signal that caused the subprocess to stop is sent. Breakpoint skipping is the same as for :r.

As for c except that the subprocess is single stepped count times. If there is no current subprocess, objfil is run as a subprocess as for :r. In this case no signal can be sent; the remainder of the line is treated as arguments to the subprocess.

Same as :c except that a temporary breakpoint is set at the next instruction. Useful for stepping across subroutines.

Execute subroutine a with parameters [b]...

Terminate the current subprocess, if any.

Change signal handling for a specified signal. Disposition d can be specified as:

For example, 0x10:z+d enables delivering of signal number 0x10 to the target process. Use $z to display existing settings.

The last value printed.

The last offset part of an instruction source.

The previous value of variable 1.

The count on the last $< command.

The base address of the data segment.

The data segment size.

The stack segment size.

The text segment size.

The entry point.

The "magic" number as defined in <magic.h>.