Document revision date: 30 March 2001

## 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

| privacy and legal statement |
4540PRO_006.HTML