HP OpenVMS Systems Documentation

HP OpenVMS Delta/XDelta Debugger Manual

1. A simple breakpoint is set in the main routine at address 30040, just prior to the subroutine call.
2. A simple breakpoint is set in the subroutine at address 30070. The breakpoints are displayed using the ;B command.
3. Program execution continues using ;P.
4. Program execution stops at breakpoint 1. DELTA/XDELTA displays the breakpoint message and the instruction at the breakpoint address. The O command is used to single-step (DELTA/XDELTA recognizes that this is not a call instruction and turns it into a single-step instead).
5. The next instruction is a subroutine call (BSR). The subroutine is stepped over using the O command.
6. Ordinarily, the step-over would continue execution at the instruction following the subroutine call. However, in this case, program execution stops at breakpoint 2 inside the subroutine at address 30070. Program execution continues with the ;P command.
7. The subroutine completes execution. DELTA/XDELTA displays a step-over break message that indicates that the O command has been completed, returning control at address 30048.

I64 example:

X0+00000380! mov         r7 = r23S            (1)
X0+00000381! nop.f       000000S
X0+00000382! br.call.sptk.many b0 = 0000E30 O (2)
X0+00000390! mov         r29 = r41S           (3)
X0+00000391! mov         r1 = r40S

1. Program execution is currently at Base Register X0, plus offset 00000380. The instruction at X0+380 is a Move Application Register instruction. Step execution is then continued using the S command.
2. Program execution is stopped at Base Register X0, plus offset 00000381. The instruction at offset 00000381 is a No Operation instruction. Step execution is then continued using the S command.
3. Program execution is stopped at offset 00000382. The instruction at 00000382 is a "br.call" instruction. Execution is continued using the O command, thus skipping the routine(s) being called.

Executes one instruction and displays the next. If the executed instruction is a call to a subroutine, it steps into the subroutine and displays the next instruction to be executed in the subroutine.

Format

S

Description

The Step Instruction command executes one instruction and displays the next instruction (in instruction mode) and its address. Use this command to single-step instructions, including single-stepping all instructions in subroutines. If you want to exclude single-stepping instructions in subroutines, use the O command.

The instruction displayed has not yet been executed. This command sets a flag to change the display mode to instruction mode. Any subsequent Close Current Location, Open Next (LINEFEED) commands and Open and Display Indirect Location (TAB) commands will display locations as machine instructions. The Open Location and Display Contents (/) command clears the flag, causing the display mode to revert to longword, hexadecimal mode.

On VAX, if the instruction being executed is a BSBB, BSBW, JSB, CALLG, or CALLS instruction, Step moves to the subroutine called by these instructions and displays the first instruction within the subroutine.

On Alpha, if the instruction being executed is a JSR or BSR instruction, Step moves to the subroutine called by these instructions and displays the first instruction within the subroutine.

Note If DELTA/XDELTA does not have write access to the target of a JSR instruction, you cannot use the S or ;P command at the JSR instruction. First, you must use the O command; then you can use the S or ;P command.

On I64, if the instruction is a br.call instruction, Step moves to the subroutine called by these instructions and displays the first instruction within the subroutine.

On Alpha and VAX, in general, you move to the instruction where you want to start single-step execution by placing a breakpoint at that instruction and typing ;P. Then press S to execute the first instruction and display the next one.

Examples

OpenVMS VAX example:

00000690/CMPL R0,#000009A8 S (1) 00000697/BEQL 0000069D S (2) 00000699/BSBB 000006A2 S (3) 000006A2/PUSHL R2 (4)

1. Step program execution is started at address 690. The instruction at 690 is executed and the next instruction is displayed. Step execution is continued using S.
2. At address 697, there is a branch instruction to the instruction at address 69D. However, because the condition (BEQL) is not met, program execution continues at the next instruction. The next S command is executed.
3. At address 699, there is a branch instruction to the instruction at address 6A2, a subroutine. The next S command is executed.
4. Program execution moves to the subroutine.

Alpha example:

0003003C! BLBC R0,#X000006 S (1) 00030040! LDQ R16,#X0050(R2) S (2) 00030044! BIS R31,R31,R17 S (3) 00030048! LDQ R26,#X0040(R2)

1. Step program execution is started at address 3003C. The instruction at 3003C is a conditional branch instruction. Step execution is continued using the S command.
2. Because the condition (BLBC) was not met, program execution continued at the next instruction at address 30040. Had the branch been taken, execution would have continued at address 30058. The second S command causes the LDQ instruction to be executed.
3. The instruction at address 30044 is displayed. The S command is executed.

I64 example:

X0+00000061! mov r52 = b0 S (1) X0+00000062! mov r40 = r1 S (2) X0+00000070! st8 [r12] = r0 ;; (3)

1. Program execution has been stopped at base register X0 plus offset 0000061. The instruction at this address is a Move Branch Register. Step execution is continued using the S command.
2. Program execution is now stopped at base register X0 plus offset 0000062. The instruction at this address is a Move Application Register. Step execution is then continued using the S command.
3. The instruction at offset 0000070 is displayed.

Deposits the ASCII string at the current address.

Format

'string'

Arguments

string

The string of characters to be deposited.

Description

The Deposit ASCII String command deposits string at the current location (.) in ASCII format. The second apostrophe is required to terminate the string. All characters typed between the first and second apostrophes are entered as ASCII character text. Avoid embedding an apostrophe (') within the string you want to deposit.

When you want to use key commands (LINEFEED, RETURN, ESC, or TAB), press the key. These commands are entered as text.

This command stores the characters in 8-bit bytes and increments the current address (.) by one for each character stored.

This command does not change the prevailing display mode.

Example

7FFE1600/'R0/[Linefeed][Linefeed]'

The ASCII string "R0/[Linefeed] [Linefeed]" is stored at address 7FFE1600. This string, if subsequently executed with the ;E command, examines the contents of general register 0 (the command R0/), then examines two subsequent registers (using two LINEFEED commands).

Evaluates an expression and displays its value.

Format

expression =

Argument

expression

The expression to be evaluated.

Description

The Display Value of Expression command evaluates an expression and displays its value in hexadecimal. The expression can be any valid DELTA/XDELTA expression. See Section 2.1 for a description of DELTA/XDELTA expressions.

All calculations and displays are in hexadecimal in the prevailing length mode.

Note Because DELTA and XDELTA treat the space as an addition operator, do not enter an unnecessary space.

Example

FF+1=00000100 (1) A-1=00000009 (2)

1. FF₁₆ and 1₁₆ are added together. DELTA/XDELTA displays the sum in hexadecimal.
2. 1₁₆ is subtracted from A₁₆. DELTA/XDELTA displays the result in hexadecimal.

Displays the ASCII text string enclosed in backslashes.

Format

\string\

Description

This mode is useful when creating your own predefined command strings. Use the backslash to begin and end an ASCII text string. Follow the ending backslash with a terminator. When DELTA or XDELTA encounters the ending backslash and terminator, it prints the ASCII text string.

This appendix gives an example of using DELTA to debug a program on OpenVMS VAX. The program, LOGINTIM, uses the system service SYS$GETJPI to obtain the login times of each process. Although this is an example of using DELTA, most of the commands in the example could be used in an XDELTA debugging session.

To run this program without error, you need WORLD privilege.

The .LIS file is listed in Example A-1. Only the offsets and source code are shown.

0000     1 ;++
0000     2 ; This sample program uses the wildcard feature of GETJPI to get the
0000     3 ; LOGINTIM for each active process.  It outputs the PID and LOGINTIM
0000     4 ; for each and exits when there are NOMOREPROCs.
0000     5 ;--
0000     6
0000     7 ;
0000     8 ; Data areas.
0000     9 ;
0000    10 DEVNAM: .ASCID /SYS$OUTPUT/         ;Output device specifier
000E
0012    11
0012    12 CHAN:   .LONG  0                    ;Assigned output channel
0016    13
0016    14 ITMLST:                             ;Item list for GETJPI call
0016    15         .WORD  8                    ; Byte length of output buffer
0018    16         .WORD  JPI$_LOGINTIM        ; Specify LOGINTIM item code
001A    17         .ADDRESS      TIME          ; Address of output buffer
001E    18         .LONG  0                    ; Not interested in return length
0022    19         .LONG  0                    ;Item list terminator
0026    20
0026    21 TIME:   .QUAD  0                    ;Buffer to hold LOGINTIM
002E    22
002E    23 OUTLEN: .LONG  0                    ;FAO buffer length
0032    24 OUTBUF: .LONG  1024                 ;FAO buffer descriptor
0036    25         .ADDRESS BUF
003A    26 BUF:    .BLKB  1024                 ;FAO buffer
043A    27
043A    28 CTRSTR: .ASCID *!/!_PID= !XW!_LOGINTIME= !%T* ;FAO control string
0448
0454
045E    29
045E    30 PIDADR: .LONG  -1                   ;Wildcard PID control longword
0462    31
0462    32 ;++
0462    33 ; Start of program.
0462    34 ;--
0462    35 S:       .WORD   0                  ;Entry mask
0464    36          $ASSIGN_S   DEVNAM,CHAN    ;Assign output channel
0475    37          MOVAB   TIME,R2            ;Load pointer to LOGINTIM
047A    38                                     ;     output buffer
047A    39 LOOP:    $GETJPI_S   ITMLST=ITMLST,-;Get LOGINTIM for a process
047A    40                  PIDADR=PIDADR
0490    41          CMPL    R0,#SS$_NOMOREPROC ;Are we done?
0497    42          BEQL    5$                 ;If EQL yes
0499    43          BSBB    GOT_IT             ;Process data for this process
049B    44          BRB     LOOP               ;Look for another process
049D    45
049D    46 5$:      MOVZBL  #SS$_NORMAL,R0     ;Set successful completion code
04A1    47          RET                        ;Return, no more processes
04A2    48
04A2    49 GOT_IT:  $FAO_S  CTRSTR,-           ;Format the output data
04A2    50                  OUTLEN,-
04A2    51                  OUTBUF,-
04A2    52                  PIDADR,R2
04B9    53          $QIOW_S CHAN=CHAN,-        ;Output to SYS$OUTPUT
04B9    54                  FUNC=#IO$_WRITEVBLK,-
04B9    55                       P1=BUF,-
04B9    56                       P2=OUTLEN
04DC    57           RSB                       ;Done with this process data
04DD    58
04DD    59           .END S

The .MAP file is listed in Example A-2. Only the Program Section Synopsis with the PSECT, MODULE, base address, end address, and length are listed.

                          +--------------------------+
                          ! Program Section Synopsis !
                          +--------------------------+

Psect Name      Module Name       Base     End           Length
----------      -----------       ----     ---           ------
. BLANK .                       00000200 000006E2 000004E3 (       1251.)
                .MAIN.          00000200 000006E2 000004E3 (       1251.)

The DELTA debugging session is listed in Example A-3.

$ DEFINE LIB$debugging SYS$LIBRARY:DELTA                             (1)
$ RUN/debugging LOGINTIM                                             (2)
DELTA Version 6.0
00000664/CLRQ    -(SP)    200,1;X                                    (3)
00000200                                                             (4)
X1 490!CMPL    R0,#000009A8   .;B                                    (5)
X1 499!BSBB    X1+04A2        .;B                                    (6)
;P                                                                   (7)

1 BRK AT 00000690
X1+0490/CMPL    R0,#000009A8  R0/00000001 ;P                         (8)
2 BRK AT 00000699
X1+499/BSBB    X1+04A2       O                                       (9)
        PID=  0000      LOGINTIME=  00:00:00.00                      (10)
X1+049B/BRB    X1+047A        ;P                                     (11)
1 BRK AT 00000690
X1+0490/CMPL    R0,#000009A8  R0/00000001 ;P                         (12)
2 BRK AT 00000699
X1+0499/BSBB    X1+04A2       O                                      (13)
        PID=  0001      LOGINTIME=  00:00:00.00
X1+049B/BRB    X1+047A        ;P
1 BRK AT 00000690
X1+0490/CMPL    R0,#000009A8                                         (14)
;B                                                                   (15)
1  00000690
2  00000699                                                          (16)
0,1;B                                                                (17)
;B                                                                   (18)
2  00000699                                                          (19)
;P                                                                   (20)
2 BRK AT 00000699
X1+0499/BSBB    X1+04A2       O
        PID=  0004      LOGINTIME=  12:50:20.40
X1+049B/BRB    X1+047A        ;P                                     (21)
2 BRK AT 00000699
X1+0499/BSBB    X1+04A2       ;P
        PID=  0005      LOGINTIME=  12:50:25.61                      (22)
2 BRK AT 00000699
X1+0499/BSBB    X1+04A2       X1 4B9!CLRQ    -(SP)                   (23)
[Linefeed]                                                             (24)
X1+04BB/CLRQ    -(SP)  [Linefeed]
X1+04BD/PUSHL    X1+002E  [Linefeed]
X1+04C1/PUSHAL    X1+003A  [Linefeed]
X1+04C5/CLRQ    -(SP)  [Linefeed]
X1+04C7/PUSHL    #00  [Linefeed]
X1+04C9/MOVZWL    #0030;-(SP)  [Linefeed]
X1+04CE/MOVZWL    X1+0012,-(SP)  [Linefeed]
X1+04D3/PUSHL     #00  [Linefeed]
X1+04D5/CALLS    #0C,@#7FFEDE00              .;B                     (25)
;B                                                                   (26)
1  000006D5
2  00000699
;P                                                                  (27)
1 BRK AT 000006D5
X1+04D5/CALLS    #0C,@#7FFEDE00              ;P                     (28)
        PID=  0006      LOGINTIME=  12:50:29.45
2 BRK AT 00000699
X1+0499/BSBB    X1+04A2       ;P                                    (29)
1 BRK AT 000006D5
X1+04D5/CALLS    #0C,@#7FFEDE00              ;P                     (30)
        PID=  0007      LOGINTIME=  12:50:37.08
2 BRK AT 00000699
X1+0499/BSBB    X1+04A2       O                                     (31)
1 BRK AT 000006D5
X1+04D5/CALLS    #0C,@#7FFEDE00              ;P                     (32)
        PID=  0008      LOGINTIME=  12:50:45.64
STEPOVER BRK AT 0000069B                                            (33)
X1+049B/BRB    X1+047A                       ;B                     (34)
1  000006D5
2  00000699                                                         (35)
0,2;B                                                               (36)
0,1;B                                                               (37)
;B                                                                  (38)
;P                                                                  (39)
        PID=  0009      LOGINTIME=  12:51:22.51
        PID=  000A      LOGINTIME=  12:51:30.26
        PID=  000B      LOGINTIME=  12:51:36.21
        PID=  000C      LOGINTIME=  12:51:58.86                     (40)
EXIT 00000001                                                       (41)
80187E7E/POPR    #03                         EXIT                   (42)

1. DELTA is enabled as the debugger.
2. The example program LOGINTIM is invoked with DELTA.
3. DELTA displays a version number and the first executable instruction. The base address of the program (determined from the map file) is virtual address 200. The base address is placed in base register 1 with ;X. Now references to an address can use the address offset notation. For example, a reference to the first instruction is X1+464 (or base address 200 + offset 464). Also, DELTA displays some address locations as offsets to the base address.
4. DELTA displays the value in base register 1, just loaded 200.
5. The instruction at address 690 is displayed in instruction mode using !. Its address location is expressed as the base address plus an offset. In the listing file, the offset is 490. The base address in base register X1 is 200. The address reference, then, is X1+490. (Note that the + sign is implied when not specified.)
   A simple breakpoint is set at that address using the ;B command. The address reference for ;B is the . symbol, representing the current address. X1+490;B would have done the same thing.
6. The same commands (! command to view the instruction and ;B to set a breakpoint) are repeated for the instruction at offset 499. When DELTA displays the instruction (BSBB GOT_IT), it displays the destination of the branch (GOT_IT) as the address location. DELTA displays the value as an offset to base register 1.
7. Program execution is begun using ;P.
8. Program execution halts at the first breakpoint. DELTA displays the breakpoint message (1 BRK AT 00000690) with the breakpoint number 1 and the virtual address. The virtual address is 00000690, which is the base address (200) plus the offset 490. DELTA then displays the instruction in instruction mode (CMPL R0,#000009A8). The contents of general register 0 are displayed with the / command. DELTA displays the contents of R0, which is 1. Program execution continues using the ;P command.
9. Program execution halts at breakpoint 2. DELTA displays the breakpoint message, then the instruction. Step-instruction execution, excluding instructions in subroutines, is initiated with O.
10. The subroutine GOT_IT is executed, and the output (PID and login time) is displayed.
11. The O command halts program execution at the instruction where the subroutine returns control (BRB LOOP). DELTA displays the instruction in instruction mode (BRB X1+047A), where X1+047A is the address of the first instruction in LOOP. Program execution continues with ;P.
12. Breakpoint 1 is encountered again; DELTA displays the breakpoint message and the instruction. The contents of R0 are examined (/ command) and program execution continues (;P).
13. Breakpoint 2 is encountered again; DELTA displays the breakpoint message and the instruction. The subroutine is stepped over again with the O command. The subroutine is executed, and the output is displayed. The instruction where the subroutine returns control is displayed. Program execution continues (;P command).
14. Breakpoint 1 is encountered; DELTA displays the breakpoint message and the instruction.
15. All breakpoints in the program are listed with the ;B command.
16. DELTA displays the breakpoints (by breakpoint number) and the address locations.
17. Breakpoint 1 is cleared using 0,[breakpoint #];B. (Never clear breakpoint 1 in XDELTA.)
18. All breakpoints are listed again with ;B command.
19. DELTA displays breakpoint 2 (breakpoint 1 cleared).
20. Program execution continues using the ;P command.
21. Breakpoint 2 is encountered; DELTA displays the breakpoint message and the instruction. The subroutine is executed with the O command and the subroutine output is displayed. The next instruction where the subroutine returns control is displayed. Program execution continues with the ;P command.
22. Breakpoint 2 is encountered; DELTA displays the breakpoint message and the instruction. Program execution continues to the next breakpoint with the ;P command. The subroutine is executed, and the subroutine output is displayed.
23. Breakpoint 2 is encountered again; the instruction at offset 4B9 (in the subroutine) is displayed using !. This instruction is part of the setup for the call to the system service $QIOW.
24. Successive address locations are displayed by pressing the Linefeed key nine times. These instructions are the remainder of the setup and the call to the system service $QIOW.
25. A breakpoint at X1+04D5 (the current address) is set using the ;B command. This breakpoint is in the subroutine. The . symbol represents the current address.
26. The current breakpoints in the program are listed. The new breakpoint is assigned breakpoint 1.
27. Program execution continues with the ;P command.
28. Program execution stops at the new breakpoint 1, which is in the subroutine GOT_IT. DELTA displays the breakpoint message and the instruction at the new breakpoint. Program execution continues with the ;P command.
29. The subroutine completes and displays the output, and program execution continues until breakpoint 2. DELTA displays the breakpoint message and the breakpoint 2 instruction. Program execution continues with the ;P command.
30. Program execution stops at breakpoint 1 in the subroutine. Program execution continues with the ;P command. The subroutine is executed, and the output is displayed.
31. Program execution stops at breakpoint 2. The O command is entered to execute and step over the subroutine.
32. Program execution stops at breakpoint 1 in the subroutine. Program execution continues with the ;P command.
33. The subroutine completes execution and displays output. DELTA displays a STEPOVER break message to state that the O command has been completed, returning control at address 69B (an instruction in the main routine).
34. The instruction where the subroutine returns is displayed, and program execution is halted. The ;B command is entered to display all current breakpoints.
35. The two current breakpoints are listed.
36. The command 0,2;B clears breakpoint 2.
37. The command 0,1;B clears breakpoint 1.
38. The ;B command is entered to display all current breakpoints. Because all breakpoints have been cleared, DELTA does not display any.
39. Program execution continues with the ;P command. Because there are no longer any breakpoints, the program executes to the end.
40. All current process login times are displayed.
41. Final exit status is displayed.
42. The DELTA EXIT command is entered to terminate the debugging session and leave DELTA.