| Previous | Contents | Index |
This command creates a DO display named EXAM at window Q2. The display shows the current values of variables A, B, and C whenever the debugger prompts for input. Any changed values are highlighted.
| #8 |
|---|
all> DISPLAY/PROCESS OUT_X AT S4
|
This command makes display OUT_X specific to the visible process (process 3) and puts the display at window S4.
Displays the contents of memory.
DUMP address-expression1 [:address-expression2]
address-expression1
Specifies the first memory location to be displayed.address-expression2
Specifies the last memory location to be displayed (default is address-expression1).
/BINARY
Displays each examined entity as a binary integer./BYTE
Displays each examined entity as a byte integer (length 1 byte)./DECIMAL
Displays each examined entity as a decimal integer./HEXADECIMAL
Displays each examined entity as a hexadecimal integer./LONGWORD (default)
Displays each examined entity in the longword integer type (length 4 bytes). This is the default type for program locations that do not have a compiler-generated type./OCTAL
Displays each examined entity as an octal integer./QUADWORD
Displays each examined entity in the quadword integer type (length 8 bytes)./WORD
Displays each examined entity in the word integer type (length 2 bytes).
The DUMP command displays the contents of memory, including registers, variables, and arrays. The DUMP command formats its output in a manner similar to the DCL command DUMP. The debugger DUMP command makes no attempt to interpret the structure of aggregates.In general, when you enter a DUMP command, the debugger evaluates address-expression1 to yield a program location. The debugger then displays the entity stored at that location as follows:
- If the entity has a symbolic name, the debugger uses the size of the entity to determine the address range to display.
- If the entity does not have a symbolic name (and, therefore, no associated compiler-generated type) the debugger displays address-expression1 through address-expression2 (if specified).
In either case, the DUMP command displays the contents of these locations as longword (by default) integer values in the current radix.
The default radix for display is decimal for most languages. The exceptions are BLISS and MACRO, which have a default radix of hexadecimal.
Use one of the four radix qualifiers (/BINARY, /DECIMAL, /HEXADECIMAL, /OCTAL) to display data in another radix. You can also use the SET RADIX and SET RADIX/OVERRIDE commands to change the default radix.
Use one of the size qualifiers (/BYTE, /WORD, /LONGWORD, /QUADWORD) to change the format of the display.
The DUMP command sets the current entity built-in symbols %CURLOC and period (.) to the location denoted by the address expression specified. Logical predecessors (%PREVLOC or the circumflex character (^)) and successors (%NEXTLOC) are based on the value of the current entity.
Related command:
EXAMINE
| #1 |
|---|
DBG> DUMP/QUAD R16:R25
0000000000000078 0000000000030038 8.......x....... %R16
000000202020786B 0000000000030041 A.......kx ... %R18
0000000000030140 0000000000007800 .x......@....... %R20
0000000000010038 0000000000000007 ........8....... %R22
0000000000000006 0000000000000000 ................ %R24
DBG>
|
This command displays general registers R16 through R25 in quadword format and hexadecimal radix.
| #2 |
|---|
DBG> DUMP APPLES
00000000 00030048 00000000 00004220 B......H....... 00000000000300B0
63724F20 746E6F6D 646F6F57 000041B0 °A..Woodmont Orc 00000000000300C0
20202020 20202020 20202073 64726168 hards 00000000000300D0
6166202C 73646E61 6C747275 6F432020 Courtlands, fa 00000000000300E0
00002020 2079636E ncy .. 00000000000300F0
DBG>
|
This command displays an entity named APPLES in longword format and hexadecimal radix.
| #3 |
|---|
DBG> DUMP/BYTE/DECIMAL 30000:30040
0 0 0 0 0 3 0 -80 °....... 0000000000030000
0 0 0 0 0 3 1 64 @....... 0000000000030008
0 0 0 0 0 3 0 48 0....... 0000000000030010
0 0 0 0 0 3 0 56 8....... 0000000000030018
0 0 0 0 0 3 0 -64 À....... 0000000000030020
0 0 0 0 0 3 0 -80 °....... 0000000000030028
0 0 0 0 0 0 7 -50 Î....... 0000000000030030
101 101 119 32 116 120 101 110 next wee 0000000000030038
107 k 0000000000030040
DBG>
|
This command displays locations 30000 through 30040 in byte format and decimal radix.
Starts the editor established with the SET EDITOR command. If you did not enter a SET EDITOR command, starts the Language-Sensitive Editor (LSE), if that editor is installed on your system.
EDIT [[module-name\] line-number]
module-name
Specifies the name of the module whose source file is to be edited. If you specify a module name, you must also specify a line number. If you omit the module name parameter, the source file whose code appears in the current source display is chosen for editing.line-number
A positive integer that specifies the source line on which the editor's cursor is initially placed. If you omit this parameter, the cursor is initially positioned at the beginning of the source line that is centered in the debugger's current source display, or at the beginning of line 1 if the editor was set to /NOSTART_POSITION (see the SET EDITOR command.)
/EXIT
/NOEXIT (default)
Controls whether you end the debugging session prior to starting the editor. If you specify /EXIT, the debugging session is terminated and the editor is then started. If you specify /NOEXIT, the editing session is started and you return to your debugging session after terminating the editing session.
If you have not specified an editor with the SET EDITOR command, the EDIT command starts the Language-Sensitive Editor (LSE) in a spawned subprocess (if LSE is installed on your system). The typical (default) way to use the EDIT command is not to specify any parameters. In this case, the editing cursor is initially positioned at the beginning of the line that is centered in the currently selected debugger source display (the current source display).The SET EDITOR command provides options for starting different editors, either in a subprocess or through a callable interface.
Related commands:
(SET,SHOW) EDITOR
(SET,SHOW,CANCEL) SOURCE
| #1 |
|---|
DBG> EDIT
|
This command spawns the Language-Sensitive Editor (LSE) in a subprocess to edit the source file whose code appears in the current source display. The editing cursor is positioned at the beginning of the line that was centered in the source display.
| #2 |
|---|
DBG> EDIT SWAP\12
|
This command spawns the Language-Sensitive Editor (LSE) in a subprocess to edit the source file containing the module SWAP. The editing cursor is positioned at the beginning of source line 12.
| #3 |
|---|
DBG> SET EDITOR/CALLABLE_EDT
DBG> EDIT
|
In this example, the SET EDITOR/CALLABLE_EDT command establishes that EDT is the default editor and is started through its callable interface (rather than spawned in a subprocess). The EDIT command starts EDT to edit the source file whose code appears in the current source display. The editing cursor is positioned at the beginning of source line 1, because the default qualifier /NOSTART_POSITION applies to EDT.
Enables the delivery of asynchronous system traps (ASTs) in your program.
ENABLE AST
The ENABLE AST command enables the delivery of ASTs while your program is running, including any pending ASTs (ASTs waiting to be delivered). If ASTs are delivered while the debugger is running (processing commands, and so on), they are queued and are delivered when control is returned to the program. Delivery of ASTs in your program is initially enabled by default.
Note
Any call by your program to the $SETAST system service that disables ASTs overrides a previous ENABLE AST command.Related commands:
(DISABLE,SHOW) AST
DBG> ENABLE AST
DBG> SHOW AST
ASTs are enabled
DBG>
|
The ENABLE AST command enables the delivery of ASTs in your program, as confirmed with the SHOW AST command.
Displays the value of a language expression in the current language (by default, the language of the module containing the main program).
EVALUATE language-expression[,...]
language-expression
Specifies any valid expression in the current language.
/BINARY
Specifies that the result be displayed in binary radix./CONDITION_VALUE
Specifies that the expression be interpreted as a condition value (the kind of condition value you would specify using the condition-handling mechanism). The message text corresponding to that condition value is then displayed. The specified value must be an integer value./DECIMAL
Specifies that the result be displayed in decimal radix./HEXADECIMAL
Specifies that the result be displayed in hexadecimal radix./OCTAL
Specifies that the result be displayed in octal radix.
The debugger interprets the expression specified in an EVALUATE command as a language expression, evaluates it in the syntax of the current language and in the current radix, and displays its value as a literal (for example, an integer value) in the current language.The current language is the language last established with the SET LANGUAGE command. If you did not enter a SET LANGUAGE command, the current language is, by default, the language of the module containing the main program.
If an expression contains symbols with different compiler-generated types, the debugger uses the type-conversion rules of the current language to evaluate the expression.
The debugger can interpret and display integer data in any one of four radixes: binary, decimal, hexadecimal, and octal. The current radix is the radix last established with the SET RADIX command.
If you did not enter a SET RADIX command, the default radix for both data entry and display is decimal for most languages. The exceptions are BLISS and MACRO, which have a default radix of hexadecimal.
You can use a radix qualifier (/BINARY, /OCTAL, and so on) to display integer data in another radix. These qualifiers do not affect how the debugger interprets the data you specify; they override the current output radix, but not the input radix.
The EVALUATE command sets the current value of built-in symbols %CURVAL and backslash (\) to the value denoted by the specified expression.
You cannot evaluate a language expression that includes a function call. For example, if PRODUCT is a function that multiplies two integers, you cannot use the command EVALUATE PRODUCT(3,5). If your program assigns the returned value of a function to a variable, you can examine the resulting value of that variable. On Alpha, the command EVALUATE procedure-name displays the procedure descriptor address (not the code address) of a specified routine, entry point, or Ada package.
For more information about debugger support for language-specific operators and constructs, type HELP Language.
Related commands:
EVALUATE/ADDRESS
MONITOR
(SET,SHOW) LANGUAGE
(SET,SHOW,CANCEL) RADIX
(SET,SHOW) TYPE
| #1 |
|---|
DBG> EVALUATE 100.34 * (14.2 + 7.9)
2217.514
DBG>
|
This command uses the debugger as a calculator by multiplying 100.34 by (14.2 + 7.9).
| #2 |
|---|
DBG> EVALUATE/OCTAL X
00000001512
DBG>
|
This command evaluates the symbol X and displays the result in octal radix.
| #3 |
|---|
DBG> EVALUATE TOTAL + CURR_AMOUNT
8247.20
DBG>
|
This command evaluates the sum of the values of two real variables, TOTAL and CURR_AMOUNT.
| #4 |
|---|
DBG> DEPOSIT WILLING = TRUE
DBG> DEPOSIT ABLE = FALSE
DBG> EVALUATE WILLING AND ABLE
False
DBG>
|
In this example, the EVALUATE command evaluates the logical AND of the current values of two Boolean variables, WILLING and ABLE.
| #5 |
|---|
DBG> EVALUATE COLOR'FIRST
RED
DBG>
|
In this Ada example, this command evaluates the first element of the enumeration type COLOR.
Evaluates an address expression and displays the result as a memory address or a register name.
EVALUATE/ADDRESS address-expression[,...]
address-expression
Specifies an address expression of any valid form (for example, a routine name, variable name, label, line number, and so on).
/BINARY
Displays the memory address in binary radix./DECIMAL
Displays the memory address in decimal radix./HEXADECIMAL
Displays the memory address in hexadecimal radix./OCTAL
Displays the memory address in octal radix.
The EVALUATE/ADDRESS command enables you to determine the memory address or register associated with an address expression.The debugger can interpret and display integer data in any one of four radixes: binary, decimal, hexadecimal, and octal.
The default radix for both data entry and display is decimal for most languages. The exceptions are BLISS and MACRO, which have a default radix of hexadecimal.
You can use a radix qualifier (/BINARY, /OCTAL, and so on) to display address values in another radix. These qualifiers do not affect how the debugger interprets the data you specify; that is, they override the current output radix, but not the input radix.
If the value of a variable is currently stored in a register instead of memory, the EVALUATE/ADDRESS command identifies the register. The radix qualifiers have no effect in that case.
The EVALUATE/ADDRESS command sets the current entity built-in symbols %CURLOC and period (.) to the location denoted by the address expression specified. Logical predecessors (%PREVLOC or the circumflex character (^)) and successors (%NEXTLOC) are based on the value of the current entity.
On Alpha, the command EVALUATE/ADDRESS procedure-name displays the procedure descriptor address (not the code address) of a specified routine, entry point, or Ada package.
Related commands:
EVALUATE
(SET,SHOW,CANCEL) RADIX
SHOW SYMBOL/ADDRESS
SYMBOLIZERoutine names in debugger expressions have different meanings on Integrity server and Alpha systems.
On Alpha systems, the command EVALUATE/ADDRESS RTN-NAME evaluates to the address of the procedure descriptor:
| #1 |
|---|
DBG> EVALUATE/ADDRESS RTN-NAME
|
On Integrity server systems, instead of displaying the address of the official function descriptor, the debugger just displays the code address. For example, on Alpha systems, you can enter the following command and then set a breakpoint when a variable contains the address, FOO:
| #2 |
|---|
DBG> SET BREAK .PC WHEN (.SOME_VARIABLE EQLA FOO)
|
The breakpoint occurs when the variable contains the address of the procedure descriptor. However, when you enter the same command on Integrity server systems, the breakpoint is never reached because, although the user variable might contain the address of the function descriptor for FOO, the "EQLA FOO" in the WHEN clause compares it to the code address for FOO. As a result, the user variable never contains the code address of FOO. However, the first quadword of an Integrity server function descriptor contains the code address, you can write it as:
| #3 |
|---|
DBG> SET BREAK .PC WHEN (..SOME_VARIABLE EQLA FOO)
|
Note
On Integrity server systems, you cannot copy the following line from your BLISS code: IF .SOME_VARIABLE EQLA FOO THEN do-something;
| #4 |
|---|
DBG> EVALUATE/ADDRESS MODNAME\%LINE 110
3942
DBG>
|
This command displays the memory address denoted by the address expression MODNAME\%LINE 110.
| #5 |
|---|
DBG> EVALUATE/ADDRESS/HEX A,B,C
000004A4
000004AC
000004A0
DBG>
|
This command displays the memory addresses denoted by the address expressions A, B, and C in hexadecimal radix.
| #6 |
|---|
DBG> EVALUATE/ADDRESS X
MOD3\%R1
DBG>
|
This command indicates that variable X is associated with register R1. X is a nonstatic (register) variable.
Displays the current value of a program variable. More generally, displays the value of the entity denoted by an address expression.
EXAMINE [address-expression[:address-expression] [,...]]
address-expression
Specifies an entity to be examined. With high-level languages, this is typically the name of a variable and can include a path name to specify the variable uniquely. More generally, an address expression can also be a memory address or a register and can be composed of numbers (offsets) and symbols, as well as one or more operators, operands, or delimiters. For information about the debugger symbols for the registers and about the operators you can use in address expressions, type Help Built_in_Symbols or Help Address_Expressions.If you specify the name of an aggregate variable (a composite data structure such as an array or record structure) the debugger displays the values of all elements. For an array, the display shows the subscript (index) and value of each array element. For a record, the display shows the name and value of each record component.
To specify an individual array element, array slice, or record component, follow the syntax of the current language.
If you specify a range of entities, the value of the address expression that denotes the first entity in the range must be less than the value of the address expression that denotes the last entity in the range. The debugger displays the entity specified by the first address expression, the logical successor of that address expression, the next logical successor, and so on, until it displays the entity specified by the last address expression. You can specify a list of ranges by separating ranges with a comma.
For information specific to vector registers and vector instructions, see /TMASK, /FMASK, /VMR, and /OPERANDS qualifiers.
/ASCIC
/AC
Interprets each examined entity as a counted ASCII string preceded by a 1-byte count field that gives the length of the string. The string is then displayed./ASCID
/AD
Interprets each examined entity as the address of a string descriptor pointing to an ASCII string. The CLASS and DTYPE fields of the descriptor are not checked, but the LENGTH and POINTER fields provide the character length and address of the ASCII string. The string is then displayed./ASCII:n
Interprets and displays each examined entity as an ASCII string of length n bytes (n characters). If you omit n, the debugger attempts to determine a length from the type of the address expression./ASCIW
/AW
Interprets each examined entity as a counted ASCII string preceded by a 2-byte count field that gives the length of the string. The string is then displayed./ASCIZ
/AZ
Interprets each examined entity as a zero-terminated ASCII string. The ending zero byte indicates the end of the string. The string is then displayed./BINARY
Displays each examined entity as a binary integer./BYTE
Displays each examined entity in the byte integer type (length 1 byte)./CONDITION_VALUE
Interprets each examined entity as a condition-value return status and displays the message associated with that return status./D_FLOAT
Displays each examined entity in the D_floating type (length 8 bytes)./DATE_TIME
Interprets each examined entity as a quadword integer (length 8 bytes) containing the internal representation of date and time. Displays the value in the format dd-mmm-yyyy hh:mm:ss.cc./DECIMAL
Displays each examined entity as a decimal integer./DEFAULT
Displays each examined entity in the default radix.The minimum abbreviation is /DEFA.
/DEFINITIONS=n
(Alpha only, Integrity servers when optimized code is supported) When the code is optimized, displays n definition points for a split-lifetime variable. A definition point is a location in the program where the variable could have received its value. By default, up to five definition points are displayed. If more than the given number of definitions (explicit or default) are available, then the number of additional definitions is reported as well. (For more information on split-lifetime variables, seeThe minimum abbreviation is /DEFI.
/EXTENDED_FLOAT
/X_FLOAT
(Integrity servers and Alpha only) Displays each examined entity in the IEEE X_floating type (length 16 bytes)./FLOAT
On Alpha, same as T_FLOAT. Displays each examined entity in the IEEE T_floating type (double precision, length 8 bytes)./FPCR
(Alpha only) Displays each examined entity in FPCR (floating-point control register) format./G_FLOAT
Displays each examined entity in the G_floating type (length 8 bytes)./HEXADECIMAL
Displays each examined entity as a hexadecimal integer./INSTRUCTION
Displays each examined entity as an assembly-language instruction (variable length, depending on the number of instruction operands and the kind of addressing modes used). See also the /OPERANDS qualifier.In screen mode, the output of an EXAMINE/INSTRUCTION command is directed at the current instruction display, if any, not at an output or DO display. The arrow in the instruction display points to the examined instruction.
Previous Next Contents Index