11.12 Sample System Code Debugging Session

To reproduce this sample session, the host system needs access to the SYSTEM_DEBUG.DSF matching the SYSTEM_DEBUG.EXE file on your target system, and to the source file C_TEST_ROUTINES.C, which is available in SYS$EXAMPLES. The target system is booted with the boot flags 0, 8004, so it stops at an initial breakpoint. The system disk is DKB200, and the network device is ESA0 in the Alpha examples and EIA0 in the Integrity server examples.

Note that the example displays from Example 11-5 onwards are all taken from an OpenVMS Integrity server system. On an OpenVMS Alpha system, some of the output is different, but the commands entered are the same on both platforms, except in one case, as noted in the accompanying text.

Example 11-1 Booting an Alpha Target System

>>> b -fl 0,8004 dkb200,esa0 INIT-S-CPU... INIT-S-RESET_TC... INIT-S-ASIC... INIT-S-MEM... INIT-S-NVR... INIT-S-SCC... INIT-S-NI... INIT-S-SCSI... INIT-S-ISDN... INIT-S-TC0... AUDIT_BOOT_STARTS ... AUDIT_CHECKSUM_GOOD AUDIT_LOAD_BEGINS AUDIT_LOAD_DONE %SYSBOOT-I-GCTFIL, Using a configuration file to boot as a Galaxy instance. OpenVMS (TM) Alpha Operating System, Version V8.3 © Copyright 1976-2006 Hewlett-Packard Development Company, L.P. DBGTK: Initialization succeeded. Remote system debugging is now possible. DBGTK: Waiting at breakpoint for connection from remote host.

A sample Integrity server Boot Menu follows (long lines wrapped for clarity).

Example 11-2 Booting an Integrity server Target System

Please select a boot option EFI Shell [Built-in] PESOS - X8.2-AHI (Topaz BL2) on $1$DGA3890:[SYS2.] PESOS - X8.2-AHI (Topaz BL2) on $1$DGA3890:[SYS2.] sysboot PESOS - E8.2-ADH (Topaz BL1) on $1$DGA3891:[SYS2.] PESOS - E8.2-ADH (Topaz BL1) on $1$DGA3891:[SYS2.] sysboot Boot Option Maintenance Menu System Configuration Menu Select the "EFI Shell [Built-in]" Loading.: EFI Shell [Built-in] EFI Shell version 1.10 [14.61] Device mapping table fs0 : Acpi(HWP0002,100)/Pci(1|1)/Scsi(Pun0,Lun0)/HD(Part2, SigB3A4A931-1F2A-11D8-9EA1-AA000400FEFF) fs1 : Acpi(HWP0002,100)/Pci(1|1)/Scsi(Pun2,Lun0)/HD(Part1, SigF7B864C3) fs2 : Acpi(HWP0002,300)/Pci(1|0)/Fibre(WWN50001FE10011B15D, Lun2200)/HD(Part1,Sig51C7BEE1-070B-11D9-8099-AA000400FEFF) fs3 : Acpi(HWP0002,300)/Pci(1|0)/Fibre(WWN50001FE10011B15D, Lun2200)/HD(Part4,Sig51C7BEE0-070B-11D9-809A-AA000400FEFF) . . . Shell> Select the desired device/partion: Shell> fs1: fs1:\>

Use the utilities in \efi\vms. Use vms_show to list the devices and vms_set to set ethernet device (debug_dev), if necessary. Note that this set is sticky so it only needs to be done once. Then load the operating system with the desired flags. Note that Alpha and Integrity servers use the same flags with the same meanings.

fs1:\> dir \efi\vms Directory of: fs1:\efi\vms 09/13/04 10:13a <DIR> 2,048 . 09/13/04 10:13a <DIR> 2,048 .. 09/13/04 10:13a <DIR> 2,048 tools 09/13/04 10:13a 3,101,184 ipb.exe 09/13/04 10:13a <DIR> 2,048 update 09/13/04 10:13a 846,336 vms_loader.efi 09/13/04 10:13a 244,224 vms_bcfg.efi 09/13/04 10:13a 218,112 vms_set.efi 09/13/04 10:13a 215,040 vms_show.efi 5 File(s) 4,624,896 bytes 4 Dir(s) fs1:\> \efi\vms\vms_show device VMS: EIA0 EFI: Acpi(000222F0,0)/Pci(3|0)/Mac(00306E39F77B) VMS: DKB200 EFI: fs1: Acpi(000222F0,100)/Pci(1|1)/Scsi(Pun2,Lun0) VMS: DKB0 EFI: fs0: Acpi(000222F0,100)/Pci(1|1)/Scsi(Pun0,Lun0) VMS: EWA0 EFI: Acpi(000222F0,100)/Pci(2|0)/Mac(00306E3977C5) . . .

Set the debug_dev to one of the connected ethernet devices:

fs1:\> \efi\vms\vms_set debug_dev eia0 VMS: EIA0 0-30-6E-39-F7-CF EFI: Acpi(000222F0,0)/Pci(3|0)/Mac(00306E39F7CF) fs1:\> \efi\vms\vms_show debug_dev VMS: EIA0 0-30-6E-39-F7-CF EFI: Acpi(000222F0,0)/Pci(3|0)/Mac(00306E39F7CF)

Boot up the OS. In this example, the boot is with the SCD and initial (early) breakpoint flags, using root 2 (SYS2), that will vary with system setups:

fs1:\> \efi\vms\vms_loader -flags "2,8004" HP OpenVMS Industry Standard 64 Operating System, V8.3 © Copyright 1976-2006 Hewlett-Packard Development Company, L.P. %EIA-I-BOOTDRIVER, Starting auto-negotiation %EIA-I-BOOTDRIVER, Auto-negotiation selected 100BaseTX FDX DBGTK: Initialization succeeded. Remote system debugging is now possible. DBGTK: Waiting at breakpoint for connection from remote host.

The example continues by invoking the system code debugger's character-cell interface on the host system.

Example 11-3 Invoking the Alpha System Code Debugger

$ define dbg$decw$display " " $ debug/keep OpenVMS Alpha Debug64 Version V8.3-003 DBG>

Example 11-4 Invoking the Integrity server System Code Debugger

$ define dbg$decw$display " " $ debug/keep OpenVMS I64 Debug64 Version V8.3-003 DBG>

Use the CONNECT command to connect to the target system. In this example, the target system's default password is the null string, and the logical name DBGHK$IMAGE_PATH is used for the image path; so the command qualifiers /PASSWORD and /IMAGE_PATH are not being used. You may need to use them.

When you have connected to the target system, the DBG> prompt is displayed. Enter the SHOW IMAGE command to see what has been loaded. Because you are reaching a breakpoint early in the boot process, there are very few images. See Example 11-5. Notice that SYS$BASE_IMAGE has an asterisk next to it. This is the currently set image, and all symbols currently loaded in the debugger come from that image.

Example 11-5 Connecting to the Target System

DBG> connect %node_name TSTSYS %DEBUG-I-INIBRK, target system interrupted DBG> show image image name set base address end address ERRORLOG no 0000000000000000 FFFFFFFFFFFFFFFF EXEC_INIT no 0000000000000000 FFFFFFFFFFFFFFFF SYS$ACPI no 0000000000000000 FFFFFFFFFFFFFFFF *SYS$BASE_IMAGE yes 0000000000000000 FFFFFFFFFFFFFFFF SYS$DKBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$DKBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$DKBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$EGBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$OPDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$PKMBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$PKMBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$PKMBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYS$PLATFORM_SUPPORT no 0000000000000000 FFFFFFFFFFFFFFFF SYS$PUBLIC_VECTORS no 0000000000000000 FFFFFFFFFFFFFFFF SYS$SRBTDRIVER no 0000000000000000 FFFFFFFFFFFFFFFF SYSTEM_DEBUG no 0000000000000000 FFFFFFFFFFFFFFFF SYSTEM_PRIMITIVES no 0000000000000000 FFFFFFFFFFFFFFFF SYSTEM_SYNCHRONIZATION no 0000000000000000 FFFFFFFFFFFFFFFF total images: 18 DBG>

Example 11-6 shows the target system's console display during the connect sequence. Note that for security reasons, the name of the host system, the user's name, and process ID are displayed.

Example 11-6 Target System Connection Display

DBGTK: Connection attempt from host HSTSYS user GUEST process 2E801C2F DBGTK: Connection attempt succeeded

To set a breakpoint at the first routine in the C_TEST_ROUTINES module of the SYSTEM_DEBUG.EXE execlet, do the following:

1. Load the symbols for the SYSTEM_DEBUG image with the DEBUG SET IMAGE command.
2. Use the SET MODULE command to obtain the symbols for the module.
3. Set the language to be C and set a breakpoint at the routine test_c_code.
   The language must be set because C is case sensitive and test_c_code needs to be specified in lowercase. The language is normally set to the language of the main image, in this example SYS$BASE_IMAGE.EXE. Currently that is not C.

Example 11-7 Setting a Breakpoint

DBG> set image system_debug %DEBUG-I-DYNLNGSET, setting language IMACRO DBG> show module module name symbols language size AUX_TARGET no C 0 BUFSRV_TARGET no C 0 BUGCHECK_CODES no BLISS 0 C_TEST_ROUTINES no C 0 LIB$$UNWIND_WEAK no BLISS 0 LIB$EF no IMACRO 0 LIB$MALLOC no C 0 LIB$MALLOC_64 no C 0 LINMGR_TARGET no C 0 OBJMGR no C 0 PLUMGR no C 0 POOL no C 0 PROTOMGR_TARGET no C 0 SOCMGR no C 0 SYS$DOINIT yes IMACRO 122526 TMRMGR_TARGET no C 0 total modules: 16 DBG> set module c_test_routines DBG> show module c_test_routines module name symbols size C_TEST_ROUTINES yes 5672 total C modules: 1 DBG> set language c DBG> show symbol test_c_code* routine C_TEST_ROUTINES\test_c_code routine C_TEST_ROUTINES\test_c_code2 routine C_TEST_ROUTINES\test_c_code3 routine C_TEST_ROUTINES\test_c_code4 routine C_TEST_ROUTINES\test_c_code5 DBG> set break test_c_code

Now that the breakpoint is set, you can proceed and activate the breakpoint. When that occurs, the debugger tries to open the source code for that location in the same place as where the module was compiled. Because that is not the same place as on your system, you need to tell the debugger where to find the source code. This is done with the debugger's SET SOURCE command, which takes a search list as a parameter so you can make it point to many places.

Example 11-8 Finding the Source Code

DBG> set source/latest sys$examples,sys$library DBG> go break at routine C_TEST_ROUTINES\test_c_code 113: x = c_test_array[0];

Now that the debugger has access to the source, you can put the debugger into screen mode to see exactly where you are and the code surrounding it.

Example 11-9 Using the Set Mode Screen Command

DBG> Set Mode Screen; Set Step Nosource - SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else 103: *pVar = (*pVar + c_test_array[17]); 104: c_test_array[7] = test_c_code3(10); 105: c_test_array[3] = test; 106: return c_test_array[23]; 107: } 108: void test_c_code(void) 109: { 110: int x,y; 111: __int64 x64,y64; 112: -> 113: x = c_test_array[0]; 114: y = c_test_array[1]; 115: x64 = c_test_array[2]; 116: y64 = c_test_array[3]; 117: c_test_array[14] = test_c_code2(x64+y64,x+y,x64+x,&y64); 118: test_c_code4(); 119: return; 120: } - OUT -output------------------------------------------------------------------- - PROMPT -error-program-prompt-------------------------------------------------- DBG>

Now, you want to set another breakpoint inside the test_c_code3 routine. You use the debugger's SCROLL/UP command (8 on the keypad) to move to that routine and see that line 93 would be a good place to set the breakpoint. It is at a recursive call. Then you proceed to that breakpoint with the GO command.

Example 11-10 Using the SCROLL/UP DEBUG Command

- SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 80: void test_c_code4(void) 81: { 82: int i,k; 83: for(k=0;k<1000;k++) 84: { 85: test_c_code5(&i); 86: } 87: return; 88: } 89: int test_c_code3(int subrtnCount) 90: { 91: subrtnCount = subrtnCount - 1; 92: if (subrtnCount != 0) 93: subrtnCount = test_c_code3(subrtnCount); 94: return subrtnCount; 95: } 96: int test_c_code2(__int64 in64,int in32, __int64 test, __int64* pVar) 97: { 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else - OUT -output------------------------------------------------------------------- - PROMPT -error-program-prompt-------------------------------------------------- DBG> Scroll/Up DBG> set break %line 93 DBG> go DBG>

When you reach that breakpoint, the source code display is updated to show where you currently are, which is indicated by an arrow. A message also appears in the OUT display indicating you reach the breakpoint at that line.

Example 11-11 Breakpoint Display

- SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 82: int i,k; 83: for(k=0;k<1000;k++) 84: { 85: test_c_code5(&i); 86: } 87: return; 88: } 89: int test_c_code3(int subrtnCount) 90: { 91: subrtnCount = subrtnCount - 1; 92: if (subrtnCount != 0) -> 93: subrtnCount = test_c_code3(subrtnCount); 94: return subrtnCount; 95: } 96: int test_c_code2(__int64 in64,int in32, __int64 test, __int64* pVar) 97: { 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else 103: *pVar = (*pVar + c_test_array[17]); 104: c_test_array[7] = test_c_code3(10); - OUT -output------------------------------------------------------------------- break at C_TEST_ROUTINES\test_c_code3\%LINE 93 - PROMPT -error-program-prompt-------------------------------------------------- DBG> Scroll/Up DBG> set break %line 93 DBG> go DBG>

Now you try the debugger's STEP command. The default behavior for STEP is STEP/OVER, unlike XDELTA and DELTA, which is STEP/INTO, so, normally you would expect to step to line 94 in the code. However, because you have a breakpoint inside test_c_code3 that is called at line 93, you will reach that event first.

Example 11-12 Using the Debug Step Command

- SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 82: int i,k; 83: for(k=0;k<1000;k++) 84: { 85: test_c_code5(&i); 86: } 87: return; 88: } 89: int test_c_code3(int subrtnCount) 90: { 91: subrtnCount = subrtnCount - 1; 92: if (subrtnCount != 0) -> 93: subrtnCount = test_c_code3(subrtnCount); 94: return subrtnCount; 95: } 96: int test_c_code2(__int64 in64,int in32, __int64 test, __int64* pVar) 97: { 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else 103: *pVar = (*pVar + c_test_array[17]); 104: c_test_array[7] = test_c_code3(10); - OUT -output------------------------------------------------------------------- break at C_TEST_ROUTINES\test_c_code3\%LINE 93 break at C_TEST_ROUTINES\test_c_code3\%LINE 93 - PROMPT -error-program-prompt-------------------------------------------------- DBG> DBG> set break %line 93 DBG> go DBG> Step DBG>

Now, you try a couple of other commands, EXAMINE and SHOW CALLS. The EXAMINE command allows you to look at all the C variables. Note that the C_TEST_ROUTINES module is compiled with the /NOOPTIMIZE switch which allows access to all variables. The SHOW CALLS command shows you the call sequence from the beginning of the stack. In this case, you started out in the image EXEC_INIT. (The debugger prefixes all images other than the main image with SHARE$ so it shows up as SHARE$EXEC_INIT. The suffix _CODE0 is appended if the executive image is sliced.)

Example 11-13 Using the Examine and Show Calls Commands

- SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 82: int i,k; 83: for(k=0;k<1000;k++) 84: { 85: test_c_code5(&i); 86: } 87: return; 88: } 89: int test_c_code3(int subrtnCount) 90: { 91: subrtnCount = subrtnCount - 1; 92: if (subrtnCount != 0) -> 93: subrtnCount = test_c_code3(subrtnCount); 94: return subrtnCount; 95: } 96: int test_c_code2(__int64 in64,int in32, __int64 test, __int64* pVar) 97: { 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else 103: *pVar = (*pVar + c_test_array[17]); 104: c_test_array[7] = test_c_code3(10); - OUT -output------------------------------------------------------------------- C_TEST_ROUTINES\test_c_code3\subrtnCount: 8 module name routine name line rel PC abs PC *C_TEST_ROUTINES test_c_code3 93 0000000000000DC0 FFFFFFFF800BAFC0 *C_TEST_ROUTINES test_c_code3 93 0000000000000DE0 FFFFFFFF800BAFE0 *C_TEST_ROUTINES test_c_code2 104 0000000000000F40 FFFFFFFF800BB140 *C_TEST_ROUTINES test_c_code 117 00000000000010B0 FFFFFFFF800BB2B0 XDT$INIT 00000000000015C0 FFFFFFFF880955C0 *SYS$DOINIT EXE$INITIALIZE 1973 0000000000000360 FFFFFFFF88094360 SHARE$EXEC_INIT_CODE0 000000000005C240 FFFFFFFF803BB640 SHARE$EXEC_INIT_CODE0 0000000000057F20 FFFFFFFF803B7320 SHARE$EXEC_INIT_CODE0 0000000000047850 FFFFFFFF803A6C50 SHARE$EXEC_INIT_CODE0 0000000000042E90 FFFFFFFF803A2290 - PROMPT -error-program-prompt-------------------------------------------------- DBG> set break %line 93 DBG> go DBG> Step DBG> examine subrtnCount DBG> show calls DBG>

If you want to proceed because you are done debugging this code, first cancel all the breakpoints and then enter the GO command. Notice, however, that you do not keep running but receive a message that you have stepped to line 94. This happens because the STEP command used earlier never completed. It was interrupted by the breakpoint on line 93.

Note that the debugger remembers all step events and only removes them once they have completed.

Example 11-14 Canceling the Breakpoints

- SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 83: for(k=0;k<1000;k++) 84: { 85: test_c_code5(&i); 86: } 87: return; 88: } 89: int test_c_code3(int subrtnCount) 90: { 91: subrtnCount = subrtnCount - 1; 92: if (subrtnCount != 0) 93: subrtnCount = test_c_code3(subrtnCount); -> 94: return subrtnCount; 95: } 96: int test_c_code2(__int64 in64,int in32, __int64 test, __int64* pVar) 97: { 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else 103: *pVar = (*pVar + c_test_array[17]); 104: c_test_array[7] = test_c_code3(10); 105: c_test_array[3] = test; - OUT -output------------------------------------------------------------------- module name routine name line rel PC abs PC *C_TEST_ROUTINES test_c_code3 93 0000000000000DC0 FFFFFFFF800BAFC0 *C_TEST_ROUTINES test_c_code3 93 0000000000000DE0 FFFFFFFF800BAFE0 *C_TEST_ROUTINES test_c_code2 104 0000000000000F40 FFFFFFFF800BB140 *C_TEST_ROUTINES test_c_code 117 00000000000010B0 FFFFFFFF800BB2B0 XDT$INIT 00000000000015C0 FFFFFFFF880955C0 *SYS$DOINIT EXE$INITIALIZE 1973 0000000000000360 FFFFFFFF88094360 SHARE$EXEC_INIT_CODE0 000000000005C240 FFFFFFFF803BB640 SHARE$EXEC_INIT_CODE0 0000000000057F20 FFFFFFFF803B7320 SHARE$EXEC_INIT_CODE0 0000000000047850 FFFFFFFF803A6C50 SHARE$EXEC_INIT_CODE0 0000000000042E90 FFFFFFFF803A2290 stepped to C_TEST_ROUTINES\test_c_code3\%LINE 94 - PROMPT -error-program-prompt-------------------------------------------------- DBG> Step DBG> examine subrtnCount DBG> show calls DBG> cancel break/all DBG> go DBG>

The STEP/RETURN command, a different type of step command, single steps assembly code until it finds a return instruction. This command is useful if you want to see the return value for the routine, which is done here by examining the R0 register on Alpha, or the R8 register on Integrity servers.

For more information about using other STEP command qualifiers, see the HP OpenVMS Debugger Manual.

Example 11-15 Using the Step/Return Command

- SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 83: for(k=0;k<1000;k++) 84: { 85: test_c_code5(&i); 86: } 87: return; 88: } 89: int test_c_code3(int subrtnCount) 90: { 91: subrtnCount = subrtnCount - 1; 92: if (subrtnCount != 0) 93: subrtnCount = test_c_code3(subrtnCount); -> 94: return subrtnCount; 95: } 96: int test_c_code2(__int64 in64,int in32, __int64 test, __int64* pVar) 97: { 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else 103: *pVar = (*pVar + c_test_array[17]); 104: c_test_array[7] = test_c_code3(10); 105: c_test_array[3] = test; - OUT -output------------------------------------------------------------------- *C_TEST_ROUTINES test_c_code3 93 0000000000000DE0 FFFFFFFF800BAFE0 *C_TEST_ROUTINES test_c_code2 104 0000000000000F40 FFFFFFFF800BB140 *C_TEST_ROUTINES test_c_code 117 00000000000010B0 FFFFFFFF800BB2B0 XDT$INIT 00000000000015C0 FFFFFFFF880955C0 *SYS$DOINIT EXE$INITIALIZE 1973 0000000000000360 FFFFFFFF88094360 SHARE$EXEC_INIT_CODE0 000000000005C240 FFFFFFFF803BB640 SHARE$EXEC_INIT_CODE0 0000000000057F20 FFFFFFFF803B7320 SHARE$EXEC_INIT_CODE0 0000000000047850 FFFFFFFF803A6C50 SHARE$EXEC_INIT_CODE0 0000000000042E90 FFFFFFFF803A2290 stepped to C_TEST_ROUTINES\test_c_code3\%LINE 94 stepped on return from C_TEST_ROUTINES\test_c_code3\%LINE 94 to C_TEST_ROUTINES\test_c_code3\%LINE 94+17 C_TEST_ROUTINES\test_c_code3\%R8: 0 - PROMPT -error-program-prompt-------------------------------------------------- DBG> show calls DBG> cancel break/all DBG> go DBG> step/return DBG> examine r8 DBG>

After you finish the SCD session, enter the GO command to leave this module. You will encounter another INI$BRK breakpoint at the end of EXEC_INIT. An error message is displayed indicating there are no source lines, because debug information on INI$BRK is not available.

Also notice that there is no message in the OUT display for this event. That is because INI$BRKs are special breakpoints that are handled as SS$_DEBUG signals. They are a method for the system code to break into the debugger and there is no real breakpoint in the code.

Enter the SHOW IMAGE command. You will see more images displayed as the boot path has progressed further.

Finally, enter GO, allowing the target system to boot completely, because there are no more breakpoints in the boot path. The debugger will wait for another event to occur.

Example 11-16 Using the Show Image Command

- SRC: module C_TEST_ROUTINES -scroll-source------------------------------------ 83: for(k=0;k<1000;k++) 84: { 85: test_c_code5(&i); 86: } 87: return; 88: } 89: int test_c_code3(int subrtnCount) 90: { 91: subrtnCount = subrtnCount - 1; 92: if (subrtnCount != 0) 93: subrtnCount = test_c_code3(subrtnCount); -> 94: return subrtnCount; 95: } 96: int test_c_code2(__int64 in64,int in32, __int64 test, __int64* pVar) 97: { 98: c_test_array[5] = in64; 99: c_test_array[6] = in32; 100: if (c_test_array[9] > 0) 101: *pVar = (*pVar + c_test_array[17]) & c_test_array[9]; 102: else 103: *pVar = (*pVar + c_test_array[17]); 104: c_test_array[7] = test_c_code3(10); 105: c_test_array[3] = test; - OUT -output------------------------------------------------------------------- SYS$UTC_SERVICES no 0000000000000000 FFFFFFFFFFFFFFFF SYS$VM no 0000000000000000 FFFFFFFFFFFFFFFF SYS$XFCACHE_MON no 0000000000000000 FFFFFFFFFFFFFFFF SYSDEVICE no 0000000000000000 FFFFFFFFFFFFFFFF SYSGETSYI no 0000000000000000 FFFFFFFFFFFFFFFF SYSLDR_DYN no 0000000000000000 FFFFFFFFFFFFFFFF SYSLICENSE no 0000000000000000 FFFFFFFFFFFFFFFF SYSTEM_DEBUG yes 0000000000000000 FFFFFFFFFFFFFFFF SYSTEM_PRIMITIVES no 0000000000000000 FFFFFFFFFFFFFFFF SYSTEM_SYNCHRONIZATION no 0000000000000000 FFFFFFFFFFFFFFFF total images: 53 - PROMPT -error-program-prompt-------------------------------------------------- DBG> go %DEBUG-I-INIBRK, target system interrupted %DEBUG-I-DYNIMGSET, setting image SYS$BASE_IMAGE %DEBUG-W-SCRNOSRCLIN, No source line for address: FFFFFFFF80000310 DBG> show image DBG> go