DEBUG EXAMINE — MicroVMS 4.4
EXAMINE is the way you find out about the value of your program
variables. In general, you can specify a location in the same
way it is specified in your source program (e.g., "EXAM X", "EXAM
A[1]", "EXAM R.C", and so on).
The value of the object is displayed according to its
compiler-generated type.
Examples:
DBG> E X ! X is floating point
PROG\X: 1.12340
DBG> E A.B[1] ! Language is PASCAL
PROG\X.B[1]: 3
Format:
EXAMINE [/qualifiers] [address-expression[:address-expression]
[,address-expression[:address-expression]...]]
Additional information available:
/ASCIC/ASCID/ASCII:n/ASCIW/ASCIZ/BINARY/BYTE
/CONDITION_VALUE/D_FLOAT/DATE_TIME/DECIMAL/DEFAULT
/FLOAT/G_FLOAT/H_FLOAT/HEXADECIMAL/INSTRUCTION
/LINE/LONGWORD/NOLINE/NOSYMBOL/OCTAL
/OCTAWORD/OPERANDS/PACKED:n/PSL/PSW
/QUADWORD/SOURCE/SYMBOL/TASK/TYPE/WORD
Aggregate
Aggregate examine allows display of entire arrays or records.
Format:
EXAMINE aggregate-name
A related feature is the ability to examine slices of arrays.
Format:
EXAMINE array_name(lower_bound:upper_bound)
Example:
DBG> EXAM R ! R is a record
PROG\R
A: 12
B: 1.3
Parameters
address-expression
Specifies the entity to be examined. In general, you use the
same syntax as in your source program (e.g., "EXAM A(1)" for a
FORTRAN array component). Sometimes, you may need to use
pathnames to disambiguate a name (e.g., "EXAM A\B\C"). See the
help on "Pathnames" for details. You can also examine arbitrary
addresses in your program that are not necessary associated with
program data (e.g., "EXAM 1000"). See the help on
"Address-expressions".
You can specify a range of addresses. For example, "EXAMINE
A(1):A(100)".
You can specify a list of objects. For example, "EXAMINE A,B,C".
Qualifiers
The qualifiers on EXAMINE are used to specify a format or a data
type or a radix other than the default. See the individual
subtopics for details.
Example:
DBG> EXAM X ! default radix is decimal
PROG\X: 17
DBG> EXAM/HEX X
PROG\X: 11 ! hexadecimal
/ASCIC
The memory location is interpreted as an ASCIC string. This is a
string with a count byte at the beginning saying how long it is.
/AC is also accepted.
Example:
DBG> EXA/HEX X
X: 33323103
DBG> EXA/AC X
X: "123"
/ASCID
The memory location is interpreted as a VAX string descriptor,
and the string is displayed. /AD is also accepted.
Example:
DBG> EXA/HEX/QUAD X
X: 7FFF0000 010E0003
DBG> EXA/ASC:3 7FFF0000
7FFF0000: "123"
DBG> EXA/AD X
X: "123"
/ASCII:n
The memory location is interpreted as an ASCII string of length
"n". If "n" is omitted the length used is the length of the
object as given in the symbol table.
Example:
DBG> EXA/ASC:3 X
X: "123"
DBG> EXA/ASC:4 X
X: "1234"
/ASCIW
Specifies that the contents of the memory location be interpreted
as a counted ascii string with a word count. /AW is also
accepted.
Example:
DBG> EXA/HEX X
X: 31310002
DBG> EXA/AW X
X: "11"
/ASCIZ
Specifies that the contents of the memory location be interpreted
as a zero-terminated string. /AZ is also accepted.
Example:
DBG> EXA/HEX X
X: 00313131
DBG> EXA/AZ X
X: "111"
/BINARY
Specifies that output should be displayed as an integer in binary
radix.
Example:
DBG> EXA X
X: 3
DBG> EXA/BIN X
X: 00000000 00000000 00000000 00000011
/BYTE
Specifies that the examined entity or entities be displayed in
the type byte integer (length 1 byte)
Example:
DBG> EXA/LONG/HEX X
X: 12345678
DBG> EXA/BYTE/HEX X
X: 78
/CONDITION_VALUE
Specified that the contents of the memory location (usually %R0
in this case) be interpreted as a return status, and the message
associated with that return status be displayed.
Example:
DBG> EXA R0
%R0: 12
DBG> E/COND R0
R0: "%SYSTEM-F-ACCVIO, access violation at PC = !XL, virtual
address = !XL
/D_FLOAT
Specifies that the examined entity or entities be displayed in
the D_floating type (length 8 bytes).
Example:
DBG> E/D_ X
X: 3.13332884848421D12
/DATE_TIME
The memory location is interpreted as a quadword integer
containing the internal VMS representation of date-time. This
value is converted to printable format and displayed.
Example:
DBG> E/DATE_TIME X
X: "12-OCT-1984:12:00:00"
/DECIMAL
Specifies that output should be displayed as an integer in
decimal radix.
Example:
DBG> E/HEX X
X: 0FFFFFFFF
DBG> E/DEC X
X: -1
/DEFAULT
Specifies that output should be displayed in the default radix.
/FLOAT
Specifies that the examined entity or entities be displayed in
the F_floating type (length 4 bytes). /F_FLOAT is also accepted.
DBG> E/F X
X: 2.345671
/G_FLOAT
Specifies that the examined entity or entities be displayed in
the G_floating type (length 8 bytes).
DBG> E/G_ X
X: 2.34747474722222
/H_FLOAT
Specifies that the examined entity or entities be displayed in
the H_floating type (length 16 bytes).
DBG> E/H_ X
X: 2.174389247892374892324879487923
/HEXADECIMAL
Specifies that output should be displayed as an integer in
hexadecimal radix.
Example:
DBG> E/DEC X
X: -1
DBG> E/HEX X
X: 0FFFFFFFF
/INSTRUCTION
Specifies that the examined entity or entities be displayed as a
VAX assembly-language instruction.
Example:
DBG> E/I .PC
%LINE 100: "MOVL B10(R4),R7"
/LINE
Turns on the symbolization to line numbers, so that code
locations are displayed as "%LINE x" instead of "routine +
offset". Mostly useful in the "SET MODE LINE" form; the
qualifier is included on EXAMINE just for completeness.
Example:
DBG> SET MODE LINE
DBG> STEP
stepped to %LINE 100
DBG> SET MODE NOLINE
DBG> STEP
stepped to ROUTINENAME + 0B7
/LONGWORD
Specifies that the examined entity or entities be displayed in
the type long integer (length 4 bytes)
Example:
DBG> EXAM F
F: 1.000000
DBG> EXAM/LONG F
F: 1024
/NOLINE
Turns off the symbolization to line numbers, so that code
locations are displayed as "routine+offset" instead of "%LINE x".
Mostly useful in the "SET MODE NOLINE" form; the qualifier is
included on EXAMINE just for completeness.
Example:
DBG> SET MODE LINE
DBG> STEP
stepped to %LINE 100
DBG> SET MODE NOLINE
DBG> STEP
stepped to ROUTINENAME + 0B7
/NOSYMBOL
Turns off the symbolization of addresses, so that locations
entered as absolute addresses will be displayed as absolute
addresses.
Example:
DBG> EXAM 512
X: 3
DBG> EXAM/NOSY 512
512: 3
/OCTAL
Specifies that output should be displayed as an integer in octal
radix.
Example:
DBG> EXAM X
X: 8
DBG> EXAM/OCTAL X
X: 10
/OCTAWORD
Specifies that the examined entity or entities be displayed in
the type octaword integer (length 16 bytes).
Example:
DBG> EXA/OCTAW/HEX X
X: 00000000 00000000 00000000 00000001
/OPERANDS
Specifies that the examined instruction display also include a
display of each operand address and its contents beneath the
instruction display.
Example:
DBG> EXAMINE/INSTRUCTION/OPERANDS .PC
X\X$START+0C: MOVL B^0A(R4),R7
operand 00000001 B^0A(R4) 0000020A: 00000100
operand 00000002 R7 R7 : 00000003
/PACKED:n
Specifies that the examined entity be interpreted as a packed
decimal number of length n nibbles.
Example:
DBG> EXAM/PACKED:5 X
X: -23412
/PSL
Specifies that the location is to be displayed in PSL format
(this is the format used when displaying the processor status
longword, i.e., "EXAM %PSL"). This is intended for use in
displaying copies of the PSL which are saved in call frames on
the stack.
Example:
DBG> EXA/PSL .SP+40
7FFF0000:
CMP TP FPD IS CURMOD PRVMOD IPL DV FU IV T N Z V C
0 0 0 0 USER USER 0 0 0 1 0 0 0 0 0
/PSW
Same as /PSL, except that only the low-order 16 bits are
displayed (the processor status word).
Example:
DBG> EXA/PSW .SP+40
7FFF0000:
DV FU IV T N Z V C
0 0 1 0 0 0 0 0
/QUADWORD
Specifies that the examined entity or entities be displayed in
the type quadword integer (length 8 bytes).
Example:
DBG> EXAM/QUAD/HEX X
X: 00000000 00000000
/SOURCE
Specifies that the parameter is to be interpreted as an address,
and the source line corresponding to the address is to be
displayed. Note - in screen mode, EXAMINE/SOURCE just has the
effect of re-positioning the source window to be centered around
the specified address.
Example:
DBG> EXAM .PC
%LINE 12: INCL R0
DBG> EXAM/SOURCE .PC
module M
12: X = X + 1
/SYMBOL
Specifies that the debugger attempt to symbolize absolute
addresses. For example:
DBG> EXAM/SYM 512
PROG\X: 3
DBG> EXAM/NOSYM 512
512: 3
/TASK
The location given by "address-expression" is interpreted as the
address of an Ada task object. Its contents are displayed as an
Ada task value.
Example:
DBG> EXAMINE/HEX ALPHA
SAMPLE.ALPHA 0016A040
DBG> EXAMINE/TASK ALPHA
SAMPLE.ALPHA %TASK 2
/TYPE=(expression)
EXAMINE/TYPE=(expression) provides a way of "type-casting". The
idea is that "expression" will be the name of a data object in
your program, and the location you are examining will be an
untyped address. The result will be that the debugger shows you
the address as if it was of the specified type.
Example: "R" is the name of a record in your program. It has
components A, an integer, and B, a floating point number. You
have also allocated an object of type R at address 2000. Then:
DBG> EXAMINE 2000 ! The debugger has no type
! information for address 2000.
2000: 12
DBG> EXAMINE/TYPE=(R) 2000 ! Show the location as if
! it were a record R.
2000:
A: 12
B: 1.7
/WORD
Specifies that the examined entity or entities be displayed as a
word integer (length 2 bytes)
Example:
DBG> EXAM/HEX X
X: 12345678
DBG> EXAM/WORD/HEX X
X: 5678