Document revision date: 19 July 1999
[Compaq] [Go to the documentation home page] [How to order documentation] [Help on this site] [How to contact us]
[OpenVMS documentation]

OpenVMS Delta/XDelta Debugger Manual
Previous Contents Index

Appendix A
Sample DELTA Debug Session on VAX

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.

Example A-1 Program for Getting LOGINTIMs 

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.

Example A-2 LOGINTIM Program .Map File 

 
                          +--------------------------+ 
                          ! 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.

Example A-3 DELTA Debugging Session Example 

 
$ 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.

Appendix B
Sample DELTA Debug Session on Alpha

This appendix gives an example of using DELTA to debug a program on OpenVMS Alpha. The C program named LOG uses the system service SYS$GETJPIW to obtain the PID, process name, and login time 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 listing file for LOG is shown in two parts. The C source code part is shown in Example B-1. The machine code part is shown in Example B-2.

Example B-1 Listing File for LOG: C Source Code 

 
1    #include <descrip.h> 
434  #include <jpidef.h> 
581  #include <ssdef.h> 
1233 #include <starlet.h> 
3784 #include <stdio.h> 
4117 #include <stdlib.h> 
4345 
4346 void print_line(unsigned long int pid, char *process_name, 
4347   unsigned long int *time_buffer); 
4348 
4349 typedef struct { 
4350   unsigned short int il3_buffer_len; 
4351   unsigned short int il3_item_code; 
4352   void *il3_buffer_ptr; 
4353   unsigned short int *il3_return_len_ptr; 
4354         } item_list_3; 
4355 
4356 #define NUL '\0' 
4357 
4358 main() 
4359   { 
4360  static char name_buf[16]; 
4361  static unsigned long int pid, time_buf[2]; 
4362  static unsigned short int name_len; 
4363 
4364  unsigned short int pidadr[2] = {-1, -1}; 
4365  unsigned long int ss_sts; 
4366  item_list_3 jpi_itmlst[] = { 
4367          /* Get's login time */ 
4368          {sizeof(time_buf), 
4369           JPI$_LOGINTIM, 
4370           (void *) time_buf, 
4371           NULL}, 
4372 
4373          /* Get's process name */ 
4374          {sizeof(name_buf) - 1, 
4375           JPI$_PRCNAM, 
4376           (void *) name_buf, 
4377           &name_len}, 
4378 
4379          /* Get's process ID (PID) */ 
4380          {sizeof(pid), 
4381           JPI$_PID, 
4382           (void *) &pid, 
4383           NULL}, 
4384 
4385          /* End of list */ 
4386          {0, 
4387           0, 
4388           NULL, 
4389           NULL} 
4390         }; 
4391 
4392 /* 
4393 While there's more GETJPI information to process and a catastrophic 
4394 error has not occurred then 
4395     If GETJPI was successful then 
4396         NUL terminate the process name string and 
4397  print the information returned by GETJPI 
4398 */ 
4399 
4400  while( 
4401           (ss_sts = sys$getjpiw(0, &pidadr, 0, &jpi_itmlst, 0, 0, 0)) != SS$_NOMOREPROC && 
4402    ss_sts != SS$_BADPARAM && 
4403    ss_sts != SS$_ACCVIO) 
4404    { 
4405   if (ss_sts == SS$_NORMAL) 
4406     { 
4407    *(name_buf + name_len) = NUL; 
4408    print_line(pid, name_buf, time_buf); 
4409     } 
4410    } 
4411  exit(EXIT_SUCCESS); 
4412   } 
4413 
4414 void print_line(unsigned long int pid, char *process_name, 
4415   unsigned long int *time_buffer) 
4416   { 
4417  static char ascii_time[12]; 
4418 
4419  struct dsc$descriptor_s time_dsc = { 
4420           sizeof(ascii_time) - 1, 
4421                  DSC$K_DTYPE_T, 
4422                  DSC$K_CLASS_S, 
4423                  ascii_time 
4424               }; 
4425  unsigned short int time_len; 
4426 
4427 /* 
4428 Convert the logged in time to ASCII and NUL terminate it 
4429 */ 
4430  sys$asctim(&time_len, &time_dsc, time_buffer, 1); 
4431  *(ascii_time + time_len) = NUL; 
4432 
4433 /* 
4434 Output the PID, process name and logged in time 
4435 */ 
4436  printf("\n\tPID= %08.8X\t\tPRCNAM= %s\tLOGINTIM= %s", pid, 
4437    process_name, ascii_time); 
4438 
4439  return; 
4440   } 
4441 __main(void *p1, void *p2, void *p3, void *p4, void *p5, void *p6) 
4442 { 
4443     void decc$exit(int); 
4444     void decc$main(void *, void *, void *, void *, void *, void *, int *, void **, void **); 
4445     int status; 
4446     int argc; 
4447     void *argv; 
4448     void *envp; 
4449  
4450     decc$main(p1, p2, p3, p4, p5, p6, &argc, &argv, &envp); 
4451  
4452     status = main 
4453                  ( 
4454  
4455  
4456  
4457                  ); 
4458  
4459     decc$exit(status); 
4460 }

Example B-2 Listing File for LOG: Machine Code 

 
                        .PSECT  $CODE, OCTA, PIC, CON, REL, LCL, SHR,- 
                                EXE, NORD, NOWRT 
0000    print_line::                                            ; 004414 
0000            LDA     SP, -80(SP)             ; SP, -80(SP) 
0004            MOV     1, R19                  ; 1, R19        ; 004430 
0008            STQ     R27, (SP)               ; R27, (SP)     ; 004414 
000C            MOV     4, R25                  ; 4, R25        ; 004430 
0010            STQ     R26, 32(SP)             ; R26, 32(SP)   ; 004414 
0014            STQ     R2, 40(SP)              ; R2, 40(SP) 
0018            STQ     R3, 48(SP)              ; R3, 48(SP) 
001C            STQ     R4, 56(SP)              ; R4, 56(SP) 
0020            STQ     FP, 64(SP)              ; FP, 64(SP) 
0024            MOV     SP, FP                  ; SP, FP 
0028            MOV     R27, R2                 ; R27, R2 
002C            STL     R17, process_name       ; R17, 16(FP) 
0030            LDQ     R0, 40(R2)              ; R0, 40(R2)    ; 004419 
0034            MOV     R16, pid                ; R16, R3       ; 004414 
0038            LDQ     R26, 48(R2)             ; R26, 48(R2)   ; 004430 
003C            LDA     R16, time_len           ; R16, 8(FP) 
0040            LDQ     R4, 32(R2)              ; R4, 32(R2)    ; 004423 
0044            LDA     R17, time_dsc           ; R17, 24(FP)   ; 004430 
0048            STQ     R0, time_dsc            ; R0, 24(FP)    ; 004419 
004C            LDQ     R27, 56(R2)             ; R27, 56(R2)   ; 004430 
0050            STL     R4, 28(FP)              ; R4, 28(FP)    ; 004419 
0054            JSR     R26, SYS$ASCTIM         ; R26, R26      ; 004430 
0058            LDL     R0, time_len            ; R0, 8(FP)     ; 004431 
005C            MOV     pid, R17                ; R3, R17       ; 004436 
0060            LDQ     R27, 88(R2)             ; R27, 88(R2) 
0064            MOV     R4, R19                 ; R4, R19 
0068            LDQ     R26, 80(R2)             ; R26, 80(R2) 
006C            MOV     4, R25                  ; 4, R25 
0070            ZEXTW   R0, R0                  ; R0, R0        ; 004431 
0074            ADDQ    R4, R0, R0              ; R4, R0, R0 
0078            LDQ_U   R16, (R0)               ; R16, (R0) 
007C            MSKBL   R16, R0, R16            ; R16, R0, R16 
0080            STQ_U   R16, (R0)               ; R16, (R0) 
0084            LDQ     R16, 64(R2)             ; R16, 64(R2)   ; 004436 
0088            LDL     R18, process_name       ; R18, 16(FP) 
008C            JSR     R26, DECC$GPRINTF       ; R26, R26 
0090            MOV     FP, SP                  ; FP, SP        ; 004439 
0094            LDQ     R28, 32(FP)             ; R28, 32(FP) 
0098            LDQ     R2, 40(FP)              ; R2, 40(FP) 
009C            LDQ     R3, 48(FP)              ; R3, 48(FP) 
00A0            LDQ     R4, 56(FP)              ; R4, 56(FP) 
00A4            LDQ     FP, 64(FP)              ; FP, 64(FP) 
00A8            LDA     SP, 80(SP)              ; SP, 80(SP) 
00AC            RET     R28                     ; R28 
 
Routine Size: 176 bytes,    Routine Base: $CODE + 0000 
00B0     main::                                                 ; 004358 
00B0            LDA     SP, -144(SP)            ; SP, -144(SP) 
00B4            MOV     48, R17                 ; 48, R17       ; 004366 
00B8            STQ     R27, (SP)               ; R27, (SP)     ; 004358 
00BC            STQ     R26, 64(SP)             ; R26, 64(SP) 
00C0            STQ     R2, 72(SP)              ; R2, 72(SP) 
00C4            STQ     R3, 80(SP)              ; R3, 80(SP) 
00C8            STQ     R4, 88(SP)              ; R4, 88(SP) 
00CC            STQ     R5, 96(SP)              ; R5, 96(SP) 
00D0            STQ     R6, 104(SP)             ; R6, 104(SP) 
00D4            STQ     R7, 112(SP)             ; R7, 112(SP) 
00D8            STQ     R8, 120(SP)             ; R8, 120(SP) 
00DC            STQ     FP, 128(SP)             ; FP, 128(SP) 
00E0            MOV     SP, FP                  ; SP, FP 
00E4            MOV     R27, R2                 ; R27, R2 
00E8            LDA     SP, -16(SP)             ; SP, -16(SP) 
00EC            LDQ     R26, 40(R2)             ; R26, 40(R2)   ; 004366 
00F0            LDQ     R18, 64(R2)             ; R18, 64(R2) 
00F4            LDA     R16, jpi_itmlst         ; R16, 16(FP) 
00F8            JSR     R26, OTS$MOVE           ; R26, R26 
00FC            LDA     R6, jpi_itmlst          ; R6, 16(FP)    ; 004401 
0100            LDQ     R3, -64(R2)             ; R3, -64(R2)   ; 004370 
0104            LDA     R7, pidadr              ; R7, 8(FP)     ; 004401 
0108            LDQ     R0, 32(R2)              ; R0, 32(R2)    ; 004364 
010C            MOV     2472, R8                ; 2472, R8      ; 004401 
0110            STL     R0, pidadr              ; R0, 8(FP)     ; 004364 
0114            LDA     R3, time_buf            ; R3, 16(R3)    ; 004370 
0118            MOV     R3, R5                  ; R3, R5 
011C            STL     R5, 20(FP)              ; R5, 20(FP)    ; 004366 
0120            LDA     R4, 8(R3)               ; R4, 8(R3)     ; 004376 
0124            STL     R4, 32(FP)              ; R4, 32(FP)    ; 004366 
0128            LDA     R17, 24(R3)             ; R17, 24(R3) 
012C            STL     R17, 36(FP)             ; R17, 36(FP) 
0130            LDA     R19, 28(R3)             ; R19, 28(R3) 
0134            STL     R19, 44(FP)             ; R19, 44(FP) 
0138    L$6:                                                    ; 004400 
0138            LDQ     R26, 48(R2)             ; R26, 48(R2)   ; 004401 
013C            CLR     R16                     ; R16 
0140            LDQ     R27, 56(R2)             ; R27, 56(R2) 
0144            MOV     R7,  R17                ; R7, R17 
0148            STQ     R31, (SP)               ; R31, (SP) 
014C            CLR     R18                     ; R18 
0150            MOV     R6, R19                 ; R6, R19 
0154            CLR     R20                     ; R20 
0158            CLR     R21                     ; R21 
015C            MOV     7, R25                  ; 7, R25 
0160            JSR     R26, SYS$GETJPIW        ; R26, R26 
0164            CMPEQ   ss_sts, 20, R16         ; R0, 20, R16   ; 004402 
0168            CMPEQ   ss_sts, R8, R17         ; R0, R8, R17   ; 004401 
016C            CMPEQ   ss_sts, 12, R18         ; R0, 12, R18   ; 004403 
0170            BIS     R17, R16, R17           ; R17, R16, R17 ; 004401 
0174            BIS     R17, R18, R18           ; R17, R18, R18 
0178            BNE     R18, L$10               ; R18, L$10     ; 004400 
017C            CMPEQ   ss_sts, 1, R0           ; R0, 1, R0     ; 004405 
0180            BEQ     R0, L$6                 ; R0, L$6 
0184            MOV     R4, R17                 ; R4, R17       ; 004408 
0188            LDQ_U   R19, 24(R3)             ; R19, 24(R3)   ; 004407 
018C            MOV     R5, R18                 ; R5, R18       ; 004408 
0190            LDA     R27, -96(R2)            ; R27, -96(R2) 
0194            EXTWL   R19, R3, R19            ; R19, R3, R19  ; 004407 
0198            ADDQ    R4, R19, R19            ; R4, R19, R19 
019C            LDQ_U   R22, (R19)              ; R22, (R19) 
01A0            MSKBL   R22, R19, R22           ; R22, R19, R22 
01A4            STQ_U   R22, (R19)              ; R22, (R19) 
01A8            LDL     R16, 28(R3)             ; R16, 28(R3)   ; 004408 
01AC            BSR     R26, print_line         ; R26, print_line 
01B0            BR      L$6                     ; L$6           ; 004405 
01B4            NOP                             ; 
01B8    L$10:                                                   ; 004400 
01B8            LDQ     R26, 80(R2)             ; R26, 80(R2)   ; 004411 
01BC            CLR     R16                     ; R16 
01C0            LDQ     R27, 88(R2)             ; R27, 88(R2) 
01C4            MOV     1, R25                  ; 1, R25 
01C8            JSR     R26, DECC$EXIT          ; R26, R26 
01CC            MOV     FP, SP                  ; FP, SP        ; 004412 
01D0            LDQ     R28, 64(FP)             ; R28, 64(FP) 
01D4            MOV     1, R0                   ; 1, R0 
01D8            LDQ     R2, 72(FP)              ; R2, 72(FP) 
01DC            LDQ     R3, 80(FP)              ; R3, 80(FP) 
01E0            LDQ     R4, 88(FP)              ; R4, 88(FP) 
01E4            LDQ     R5, 96(FP)              ; R5, 96(FP) 
01E8            LDQ     R6, 104(FP)             ; R6, 104(FP) 
01EC            LDQ     R7, 112(FP)             ; R7, 112(FP) 
01F0            LDQ     R8, 120(FP)             ; R8, 120(FP) 
01F4            LDQ     FP, 128(FP)             ; FP, 128(FP) 
01F8            LDA     SP, 144(SP)             ; SP, 144(SP) 
01FC            RET     R28                     ; R28 
 
Routine Size: 336 bytes,    Routine Base: $CODE + 00B0 
0200    __main::                                                ; 004441 
0200            LDA     SP, -48(SP)             ; SP, -48(SP) 
0204            MOV     9, R25                  ; 9, R25        ; 004450 
0208            STQ     R27, (SP)               ; R27, (SP)     ; 004441 
020C            STQ     R26, 24(SP)             ; R26, 24(SP) 
0210            STQ     R2, 32(SP)              ; R2, 32(SP) 
0214            STQ     FP, 40(SP)              ; FP, 40(SP) 
0218            MOV     SP, FP                  ; SP, FP 
021C            LDA     SP, -32(SP)             ; SP, -32(SP) 
0220            MOV     R27, R2                 ; R27, R2 
0224            LDA     R0, argc                ; R0, 16(FP) ; 004450 
0228            LDQ     R26, 48(R2)             ; R26, 48(R2) 
022C            LDA     R1, argv                ; R1, 12(FP) 
0230            STQ     R0, (SP)                ; R0, (SP) 
0234            LDA     R0, envp                ; R0, 8(FP) 
0238            STQ     R1, 8(SP)               ; R1, 8(SP) 
023C            LDQ     R27, 56(R2)             ; R27, 56(R2) 
0240            STQ     R0, 16(SP)              ; R0, 16(SP) 
0244            JSR     R26, DECC$MAIN          ; R26, R26 
0248            LDA     R27, -96(R2)            ; R27, -96(R2) ; 004452 
024C            BSR     R26, main               ; R26, main 
0250            LDQ     R27, 40(R2)             ; R27, 40(R2)   ; 004459 
0254            MOV     status, R16             ; R0, R16 
0258            MOV     1, R25                  ; 1, R25 
025C            LDQ     R26, 32(R2)             ; R26, 32(R2) 
0260            JSR     R26, DECC$EXIT          ; R26, R26 
0264            MOV     FP, SP                  ; FP, SP        ; 004460 
0268            LDQ     R28, 24(FP)             ; R28, 24(FP) 
026C            LDQ     R2, 32(FP)              ; R2, 32(FP) 
0270            LDQ     FP, 40(FP)              ; FP, 40(FP) 
0274            LDA     SP, 48(SP)              ; SP, 48(SP) 
0278            RET     R28                     ; R28 
 
Routine Size: 124 bytes,    Routine Base: $CODE + 0200

Previous Next Contents Index

  [Go to the documentation home page] [How to order documentation] [Help on this site] [How to contact us]  
  privacy and legal statement  
4540PRO_006.HTML