Copy Link
Add to Bookmark
Report
Chapter 3
CHAPTER 3 - Debugging In 30 Minutes
03.01 Introduction
03.02 Popping Up the Window
03.03 Returning From the Window
03.04 Changing the Window Size
03.05 Moving the Window
03.06 Line Editing Keystrokes
03.07 Interactive Status Line
03.08 Command Syntax
03.08.01 Specifying Memory Addresses
03.09 Function Keys
03.10 Help
03.11 Tutorial
03.01 Introduction
All interaction with Soft-ICE takes place through a window that can be
popped up at any time. All Soft-ICE commands fit in a small window,
but the window can be enlarged to full screen. You will typically use
the small window when using Soft-ICE as an assistant to another
debugger, and the large window when using Soft-ICE in stand-alone
mode.
The window initially comes up in full screen mode if you are using the
Soft-ICE configuration file (S-ICE DAT) that was included on the
distribution diskette.
03.02 Popping Up the Window
You can bring up the window at any time after installing Soft-ICE. You
initially bring up Soft-ICE by pressing the CTRL D keys. However, this
sequence can be changed by using the ALTKEY command (see section 5.8).
03.03 Returning From the Window
Return to the original display by using the X command or the key
sequence that you used to invoke Soft-ICE. Any break points that you
set while working in Soft-ICE will be armed at this point.
03.04 Changing the Window Size
You can modify both the width and the height of the Soft-ICE window.
Changing the window size is particularly useful in stand-alone mode
when you are displaying code memory.
The window height can vary from 8 to 25 lines tall. To change the
window height, use the following key sequences:
ALT UP : makes the window taller
ALT DOWN : makes the window shorter
To change the window width, use the WIN command (see section 5.9).
Entering WIN with no parameters toggles between the following two
modes:
WIDE mode : full screen width
NARROW mode : 46 characters wide
Some commands (D, E, R, U) take advantage of the extra width by
displaying more information when the window is in wide mode.
03.05 Moving the Window
The Soft-ICE window is movable and can be positioned anywhere on the
screen. This is particularly useful when the window is in narrow mode.
Move the window anytime you need to view information on the screen
behind the window. The following key sequences move the window:
CTRL UP : moves the window one row up
CTRL DOWN : moves the window one row down
CTRL RIGHT : moves the window one column right
CTRL LEFT : moves the window one column left
03.06 Line Editing Keystrokes
Soft-ICE's easy-to-use line editor allows you to recall and edit
previous commands. The line editor functions are similar to those of
the popular CED line editor. The following key sequences help you edit
commands in the command window :
LEFT : moves the cursor to the right
RIGHT : moves the cursor to the left
INS : toggles insert mode
DEL : deletes the current character
HOME : moves the cursor to start of the line
END : moves the cursor to the end of the line
UP : displays the previous command
DOWN : displays the next command
SHIFT : scroll one line up in display
SHIFT : scroll one line down in display
PAGE UP : scroll one page up in display
PAGE DN : scroll one page down in display
BKSP : deletes the previous character
ESC : cancels the current command
There are special key assignments when the cursor is in the data
window or the code window. These are described in the sections for the
E and EC command respectively. One special assignment of note is the
SHIFT UP and SHIFT DOWN keys while the cursor is in the code window.
These keys are re-assigned so they have the functions that UP and DOWN
normally have. This way you can recall previous commands while the
cursor is in the code window.
03.07 Interactive Status Line
A status line at the bottom of the window provides interactive help
with command syntax.
03.08 Command Syntax
Soft-ICE is a command-driven debugging tool. To interact with
Soft-ICE, you enter commands, which can optionally be modified by
parameters.
All commands are text strings that are one to six characters in length
and are case insensitive. AlI parameters are either ASCII strings or
expressions.
Expressions are typically numbers, but can also be combinations of
numbers and operators (e.g., + - / *). All numbers are displayed in
hexadecimal format. Byte parameters are 2 digits long, word parameters
are 4, and double word parameters are 2 word parameters separated by a
colon (:). Here are some examples of parameters:
12 : byte parameter
10FF : word parameter
E000:0100 : double word parameter
Registers can be used in place of bytes or words in an expression. For
example, the command 'U CS:IP-10' will start unassembling instructions
ten bytes before the current instruction pointer address. The
following register name may be used in an expression: AL, AH, AX, BL,
BH, BX, CL, CH, CX, DL, DH, DX, DI, SI, BP, SP, IP, CS, DS, ES, SS, or
FL
03.08.01 Specifying Memory Addresses
Many Soft-ICE commands require memory addresses as parameters. A
memory address is a value that is made of two 16-bit words, separated
by a colon. The first word is the segment address, and the second word
is the segment offset.
Public symbols can be used in place of an address in any Soft-ICE
command. The public symbols must have been loaded with the Soft-ICE
program loader (LDR.EXE). See chapter 7 (Symbols and Source) for a
complete description of using public symbols.
The Soft-ICE expression evaluator recognizes several special
characters in conjunction with addresses. These special characters
are:
$ : Current CS:IP.
@address : Double Word Indirection
.number : Source Line Number
The $ character can be used in place of CS:IP when typing the address
of the current instruction pointer.
The @ character allows you to refer to the double word pointed to by
the address. You can have multiple levels of @'s.
If the . character precedes an address, the address will be
interpreted as a source line number in the current file, rather than
an actual address. This is only valid when source files are loaded.
The address is interpreted as a decimal number in this case. Examples:
U.1234 : This command starts unassembling instructions at source
line 1234 decimal.
U $-10 : This command unassembles instructions starting 10 bytes
prior to the current instruction pointer.
G @SS:SP : Assume you are at the first instruction of an interrupt
routine. Entering this command will set a temporary break
point at the return address on the stack and skip the
interrupt routine.
03.09 Function Keys
Function keys can be assigned to any command string that can be typed
into Soft-ICE. Function keys can be assigned from the command line or
pre-initialized through the Soft-ICE definition file S-ICE.DAT.
The default S-ICE.DAT that comes on the Soft-ICE distribution diskette
has definitions for all 12 function keys. You can change any of these
definitions at any time. They are intended as examples, but they are
designed to make easy for users of Microsoft's CodeView, Thee default
assignments are:
F1 : Displays general help "^H;"
F2 : Toggles the register window "^WR;"
F3 : Changes current source mode "^SRC;"
F4 : Restores screen "^RS;"
F5 : Returns to your program "^X;"
F6 : Toggles cursor between command window code window "^EC;"
F7 : Goes to current cursor line "^HERE;"
F8 : Single steps "^T;"
F9 : Sets break point at current cursor line "^BPX;"
F10 : Program steps "^P;"
F11 : Go to return address (large model) "^G @SS:SP;"
F12 : Displays Soft-ICE version number "^VER;"
A caret (^) preceding a command makes it invisible, a semi-colon (;)
following a command represents a carriage return. You can display the
current function key assignments by entering the command:
FKEY
To use a function key simply press the function key instead of
entering the command. To program function keys see section 5.8 for a
description of the FKEY command, or chapter 6 for a description of
pre-initializing function keys in S-ICE.DAT.
03.10 Help
The help command displays a short description, a syntax expression,
and an example of each command. To display help information, enter:
? or H : displays short descriptions of all commands and operators
? command or H command : displays more detailed information on the
specified command, syntax, and an example
? expression or H expression : displays the value of the expression
in hexadecimal, decimal and ASCII
03.11 Tutorial
The following tutorial demonstrates a few of the features Soft-ICE and
gives you the opportunity to try using Soft-ICE. Soft-ICE can be used
in conjunction with another debugger or as a stand-alone debugger. The
tutorial demonstrates using Soft-ICE as an assistant to the DOS
debugger, DEBUG, and then shows how Soft-ICE can be used as a
stand-alone debugger with source and symbols loaded. DEBUG can be
found on the PCDOS or MSDOS system diskette. If you do not have DEBUG,
you can use another debugger in its place, or Soft-ICE can be used as
a stand-alone debugger.
Users who need to use Soft-ICE for a reverse engineering project, or
for debugging DOS loadable device drivers or Terminate and Stay
Resident programs should go through this tutorial too. Even though
examples of these types of programs are not demonstrated directly, you
will get an overview of debugging with Soft-ICE. It is recommended
that you experiment with Soft-ICE and your particular environment
before beginning a real project.
A short assembly language program with a subtle flaw is used to
demonstrate hardware-style break points. The sample program has been
kept intentionally short and to-the-point for those not very familiar
with assembly language. The tutorial is designed to give you a peek at
Soft-ICE features. Feel free to experiment on your own after going
through the tutorial.
Since Soft-ICE is very flexible, it allows you to load in the way that
is best for your system. Go through the installation procedures in
section 2.2 before continuing with the tutorial.
If you do not have extended memory on your system, you must load
Soft-ICE from the command line. When loading Soft-ICE from the command
line you can not load symbols or source files. In this case you must
improvise in the last section of the tutorial where Soft-ICE is used
as a stand-alone debugger.
Soft-ICE can be loaded from the DOS prompt or loaded as a device
driver in CONFIG.SYS. For the purpose of this tutorial you should
install Soft-ICE in CONFIG.SYS with at least 50K of extended memory
reserved for symbols and source files. Soft-ICE should be the first
device driver installed in CONFIG.SYS. The device installation line
should look like:
DEVICE = drive: path\S -ICE.EXE /SYM 50
The /SYM 50 parameter instructs Soft-ICE to reserve 50 kilobytes of
extended memory for symbols and source file This is not enough to
solve most real world problems, but will work for our sample program.
You must re-boot your system after placing this line in CONFIG.SYS.
When you re-boot your system Soft-ICE displays a copyright notice, a
registration number, the name of the person who owns this copy of
Soft-ICE, and the amount a extended memory reserved for each Soft-ICE
component. On a system with 384K of extended memory the initial screen
looks like:
Soft-ICE Exact /Out Rage Pirates Registration # SI123456
(C) Nu-Mega Technologies 1987-1989 All Rights Reserved.
Soft-ICE Version 2.00
Soft-ICE is loaded from 00132000H up to 00160000H.
50K of symbol space reserved.
10K of back trace space reserved.
200 K of extended memory available.
The "Soft-ICE is loaded ..." message tells you the exact area of
memory that Soft-ICE and its components are occupying. If you are on a
Compaq or Compaq clone and have included the word COMPAQ in your
S-ICE.DAT file you would also see a message saying "Using high memory
from XXXXXXXX to 00FE0000H".
The next line tells you how much symbol space has been reserved. This
space is used for both symbols and source files.
The next line tells you how much memory has been reserved for back
trace history. This amount defaults to 10K. This memory area is used
by the SNAP command and the BPR command with the T or TW options.
The last line tells you how much memory is left for regular extended
memory. This memory can be used by other programs, such as HIMEM,
SMARTDRIVE, VDISK, etc.
Change directories to the hard drive directory where you loaded all
the files from your distribution diskette. Remember, this directory
must be accessible from your alternate path list.
Before we get into heavy debugging, let's bring the Soft-ICE window up
and give it a test drive. Clear the screen by entering : CLS and bring
up the Soft-ICE window by pressing : CTRL D.
The Soft-ICE window is now on the screen. If you have file S-ICE.DAT
accessible from your path then the Soft-ICE window will occupy the
entire screen. It will be divided into four sections. From top to
bottom, these sections are the register window, the data window, the
code window, and the command window. If S-ICE.DAT was not found then
you will have a small window in the center of the screen. This also
means that other components needed for the tutorial have not been
loaded.
If the small window is visible you should:
1. Exit from Soft-ICE by entering X.
2. Unload Soft-ICE by entering S-ICE /U.
3. Copy the file S-ICE.DAT from the distribution diskette to a
directory accessible from your current path.
4. Restart the demo.
We will now switch to the small window. The small window is very
convenient for using Soft-ICE as an assistant to another debugger.
Enter : WIN
This will make a small command window in the center of the screen.
Several Soft-ICE commands are visible on this screen. These are
remnants of the initialization string in S-ICE.DAT that originally set
up Soft-ICE in the full screen mode. You will notice a prompt symbol
(:) and a status line at the bottom of the window.
The Soft-ICE window can be moved around on the screen, and the window
size can be adjusted. Move the window around the screen by pressing:
CTRL UP : moves the window one row up
CTRL DOWN : moves the window one row down
CTRL RIGHT : moves the window one column right
CTRL LEFT : moves the window one column left
Change the window size so that it fills the whole screen by entering :
WIN. You will notice that the original screen is back. Change back to
the small window by entering WIN again. Make the window taller or
shorter by pressing :
ALT UP : makes the window taller
ALT DOWN : makes the window shorter
Now try what comes naturally when you're in front of a new program and
you don't have the foggiest notion of what to do next, ask for help.
Get a help display by entering : ?
Notice how the display stops and waits for a keystroke before
scrolling any information off the screen. Look at the status line at
the bottom of the window. The status line displays the instructions:
"Any Key To Continue, ESC to Cancel ". Now press any key to continue
displaying more the help information. Continue pressing the key until
the prompt (:) reappears.
Scroll back through the help information by pressing : SHIFT.
Previously displayed information in the command window can be scrolled
with the shift up, shift down, page up and page down keys. Try a
variety of these keys to scroll through the help information.
The Soft-ICE help facility gives you an overview of each command. If
you enter a question mark (?) followed by a command name, you see a
display showing the command syntax, a short description of the
command, and an example. Try experimenting with help by entering
commands in this format: ? command.
For example, ? ALTKEY. Pay attention to the status line prompts on the
bottom line of the screen if you get confused.
The help command also allows you to evaluate hexadecimal expressions.
For example, enter : ? 10*2+42. The resulting display shows you the
value of the expression, first in hexadecimal, then decimal, then in
ASCII representation : 0062 00098 "b"
We brought up the window with the CTRL D key sequence. That's all
right for some, but you may prefer to use another key sequence. We are
now going to enter a command to change the key sequence required to
bring up the window. We'll do this one step at a time, so you can get
used to the status line at the bottom of the window.
Type the letter 'A'. The status line displays a list of all the
commands starting with the letter 'A'. Finish typing the word
'ALTKEY'. The status line now displays a short description of the
/ALTKEY command Press the space bar. The status line now shows the
required syntax for the /ALTKEY command. Type the letters 'ALT D' then
press ENTER to enter the entire command : ALTKEY ALTD
You just changed the window pop up key sequence to ALT D. From now on,
you must press the ALT D key sequence to pop up the window. This is
assumed throughout the remainder of the tutorial. Now let's test the
previous command. To exit from the window, press : ALT D
The Soft-ICE window just disappeared. To return to the Soft-ICE
window, release the ALT key, then press: ALT D The window returned.
To see some previous commands, press: the UP key a few times. Notice
that Soft-ICE remembers commands that have been entered. Try editing
one just for fun. Some of the editing keys are:
INS : toggles insert mode
DEL : deletes the current character
HOME : moves the cursor to start of the line
END : moves the cursor to the end of the line
LEFT : Moves the cursor one column to the right
RIGHT : Moves the cursor one column to the left
When insert mode is on, notice that the cursor is in a block shape.
Now that you are somewhat familiar with the environment let's try some
more commands. Erase the command you were editing by pressing the HOME
key, then pressing the DEL key until the command is gone. Enter : WR.
The WR command makes the register window visible. The register window
displays the contents of the 8086 registers. Notice that the register
values reflect the location where the code was executing when you
invoked Soft-ICE.
The WR command is assigned to the function key F2 in the Soft-ICE
initialization file S-ICE.DAT. Press the F2 key several times and you
will see the register window toggle on and off. Leave the register
window visible.
Extend the vertical size of the Soft-ICE window by holding down the
ALT and the until the window is the entire length of the screen.
Notice the values of the CS and IP registers in the register window,
then enter : MAP
The MAP command displays a system memory map. The area of the current
instruction pointer (CS:IP) is highlighted. If you have a complex
memory map you may have to press a key a few times until the until the
prompt reappears.
Now try the following sequence a few times, noticing the (CS:IP)
registers in the register window. ALT D, release ALT and D, ALT D
Each time you bring the Soft-ICE window back up you will notice that
the CS and IP registers have changed. When CS and IP change you can
enter the MAP command again to see if the instruction pointer now
points to a different area. This little exercise demonstrates that
Soft-ICE is a system level debugger that pops up wherever the
instruction pointer happens to be when you press the Soft-ICE hot key
sequence. The instruction pointer is continuously changing because
there is a lot of activity happening behind the scenes even when you
are at the DOS prompt, such as timer interrupts, DOS device driver
polling, DOS busy waiting other interrupts, etc.
Press the F12 function key. The F12 function key defaults to be
assigned to the Soft-ICE VER command. It displays the Soft-ICE
copyright message and the version number.
We will now assign the F12 function key to the Soft-ICE RS command.
Enter : RS. This will temporarily show the program screen without the
Soft-ICE window. Press the space bar to get back to get back the
Soft-ICE window. Enter : FKEY F12 RS;
This assigns the RS command to the F12 key. The semi-colon represents
the ENTER key. Press the F12 key. Repeat this a few times to toggle
between the Soft-ICE window and the program screen. Now make sure the
Soft-ICE window is displayed, by pressing the F12 key if necessary.
You will notice RS displayed several times in the window. There is one
occurrence for each time you pressed the F12 key to show the program
screen.
Clear the Soft-ICE window by entering : CLS. Enter : FKEY F12 ^RS;.
The ^ symbol assigns the RS command to the F12 key, but makes it an
invisible command. Press the F12 key several times. Notice that the RS
command no longer displays in the Soft-ICE window. You can also assign
a sequence of Soft-ICE commands to a function key. Remember to place a
carriage return between each command.
Now let's prepare to use Soft-ICE as an assistant to the MSDOS DEBUG
utility. Get rid of the register window by pressing the F2 then shrink
the window size down to about 6 lines by Using ALT. Enter : ACTION
INT3
This command tells Soft-ICE to generate interrupt 3's when break point
conditions are met. That's how Soft-ICE will communicate with DEBUG.
The default setting is HERE. ACTION HERE will cause control to return
directly to Soft-ICE. Use ACTION HERE when using Soft-ICE as a
stand-alone debugger.
For those of you not using DEBUG with this tutorial you might have to
improvise now. CODEVIEW works with ACTION NMI. Most other debuggers
will work with ACTION set to INT3. If your debugger doesn't, and you
need help improvising, refer to the complete description ACTION (see
section 5.4).
To make the Soft-ICE window disappear again, enter : X. This is an
alternative method to exit from Soft-ICE. This especially useful in
function key definitions.
Now that you are familiar with some of the basics of using Soft-ICE,
let's learn some details by debugging the sample program (SAMPLE.ASM).
SAMPLE.ASM is a simple program written in assembly language by a
programmer named Jed. The program reads a keystroke from DOS and
displays a message telling whether the keystroke was a space.
To run the program SAMPLE, at the DOS prompt, enter : SAMPLE
Now press the space bar. Press several keys. Jed's program obviously
has a problem! Jed has spent hours studying this source code and is
certain there are no flaws in his logic. However, Jed borrowed some
'helper' routines from his friend Jake (get_key, is_space?). Jed is
somewhat suspect these routines but he cannot find the bug. The source
code for Jed's program looks like this:
Page 55,80
Title Sample
DATA Segment Public 'Data'
pad db 12H dup(O)
char db 0
answer db 0
space_msg db 'The Character is a SPACE',0DH,0AH,'$'
no_space_msg db 'The Character is NOT a'
db 'SPACE',0DH,0AH,'$'
DATA Ends
STACK Segment Stack 'Stack'
Dw 128 Dup (?) ;Program stack
STACK Ends
CODE Segment Public 'Code'
Assume CS:CODE,DS:DATA,ES:Nothing,SS:STACK
start:
mov ax,DATA ; Set up segments
mov es,ax
mov ds,ax
main_loop: ; Main Program Loop
call get_key
call is_space
cmp answer,0
je no_space
; It's a space, so display the space message
mov ah,9
mov dx,offset space_msg
int 21H
jmp main_loop
; It's NOT a space, so display the no space message
no_space:
mov ah,9
mov dx,offset no_space_msg
int 21H
jmp main_loop
;----------------------------------------------------------;
; JAKE'S ROUTINES ;
;----------------------------------------------------------;
; Get Key Routine (one of Jake's routines)
get_key proc
mov ah,8
int 21H
mov char,al
ret
get_key endp
; Check if character is a space (one of Jake's routines)
is_space proc
cmp char,20H
jne not_space
mov answer, 1
ret
not_space:
mov cs:answer,0
ret
is_space endp
CODE Ends
End.
Jed has been using DEBUG but has not been able to pinpoint the
problem. As a recommendation from his nephew Jethro, Jed has purchased
Soft-ICE. He was somewhat reluctant to use it because he had tried a
hardware-assisted debugger but could never get it working quite right.
He was willing to try Soft-ICE because he could continue to use DEBUG
-- the only debugger he really understood.
Press CTRL C to break out of the program. Enter the following
commands:
DEBUG drive:\pathname\SAMPLE. EXE
U
R
In the hours Jed has spent trying to find this elusive bug, he has had
the suspicion that something is overwriting his code in some subtle
way. With Soft-ICE, Jed decides to set a range break point across his
code segment. Press : ALT D. The Soft-ICE window is back. Move the
window (by using CTRL and the Arrow keys) until DEBUG's register
display is visible.
It's time to set our first break point. Enter : BPR code-seg:0
code-seg:25 W
Code-seg is the value in the CS register as displayed by the DEBUG R
command.
The BPR command sets a memory-range break point. The length of Jed's
code segment is 25H bytes, so the memory range specified goes from the
beginning of his code segment to the end. The W tells Soft-ICE to
break on a write. We want to catch any unexpected writes to Jed's
code.
Enter : BL
The BL command displays all break points. The display from BL looks
similar to the following display :
0) BPR code-seg:0000 code-seg:0025 W C = 01
The 0 is the identifier for this break point. The range and W are
displayed as they were entered, and the count (since none was
specified) defaults to one. Now comes the moment of truth. Press ALT D
The window disappears again. To run SAMPLE from DEBUG, enter : G.
Press the space bar. Ok so far. Now press a non-space key. Our break
point just woke up DEBUG. The registers and single unassembled
instruction are displayed. Enter : U cs:address
Address is the value of the IP register minus 10 hexadecimal. Since
DEBUG is rather primitive, the value of the IP register minus 10
hexadecimal must be calculated by hand. The instruction pointer is
pointing one instruction past the instruction that caused the break
point. By going back ten hexadecimal instructions, DEBUG should sync
up. The instruction at offset 3BH is:
CS:
MOV BYTE PTR [13],0
Jed says,"There it is! I just knew Jake's helper routines were the
problem! His code segment override instruction is writing a zero byte
right over my code! Who knows what that's doing!". Enter : U 0
Location 13H happens to be the offset of a conditional jump
instruction. The relative offset of the conditional jump is being set
to zero. If you are an 8086 guru, you obviously know that the JE will
ALWAYS fall through if the relative offset is zero. What a subtle BUG!
Now we will take a quick look at how this problem would be solved
using Soft-ICE as a stand-alone debugger. But first we must exit from
debug.
Before exiting the debugger, it's always a good idea to disable all
the break points, unless ACTION is set to HERE. If you do not do this,
when a break point occurs and ACTION tries to return to a debugger
that is not loaded, the results are unpredictable. We've changed the
ACTION to INT3, so we have to disable the break point. To bring up the
window, press : ALT D. List the break point by entering : BL
Notice that the break point description line is highlighted. The
highlighted break point is the last break point that occurred. Notice
that the break point number is 0. To disable break point zero, enter :
BD 0
List the break point again by entering : BL. The asterisk (*) after
the break point number shows that the break point is disabled. To
clear the break point, enter : BC 0
Enter BL again. Notice that there are no break point lines displayed.
Exit from Soft-ICE, then exit from the debugger, by entering :
X
Q
The next part of the tutorial demonstrates how Soft-ICE can be used to
find the same problem as a stand-alone debugger. Soft-ICE will be used
as a source level debugger. To prepare Soft-ICE to debug at source
level it must have been installed in your CONFIG.SYS file, and
extended memory allocated for symbols and source files. Soft-ICE can
only be used as a source level debugger if you have extended memory on
your system. If you do not have extended memory you may still want to
read through the rest of the tutorial to see the capabilities of
Soft-ICE with extended memory. If you have not loaded S-ICE.EXE in
your CONFIG.SYS file with memory reserved for symbols, do so at this
time.
To debug the sample program with Soft-ICE as a stand-alone debugger we
must use the Soft-ICE program loader (LDR.EXE). To load the sample
program (SAMPLE.EXE), the symbol file (SAMPLE.SYM) and the source file
(SAMPLE.ASM) enter at the DOS prompt :LDR SAMPLE
You are now in Soft-ICE with SAMPLE.EXE loaded into memory. Notice
that Soft-ICE occupies the full screen. Soft-ICE switches to its wide
mode whenever a program loaded. The source from SAMPLE.ASM should be
visible in the code window. In addition, the register window and the
DATA windows are visible.
Step through one instruction by pressing F10. Notice that the reverse
video bar moves to the next instruction to be executed after a program
step.
Press F6. This places the cursor in the code window. Now experiment
with the Up, Down, pageUp, and pageDn keys to move the cursor and
scroll the source file. Move the cursor down to line 42 with the DOWN
key. Press F9.
We have just set an execution break point on line 42. The line should
be highlighted, showing you that a break point has been set on it.
Enter : BL. This shows the break point that we have just set.
Now press ALT D. This exits Soft-ICE, and causes the sample program to
execute until it encounters the break point on line 42. Soft-ICE
should immediately come back, with the reverse video bar on line 42.
Press F6 again. This will bring the cursor back to the command window.
Now enter : BC *. This will clear all the break points (there should
only be one set). Now exit from Soft-ICE by pressing ALT D. You are
back to the sample program. Type a few keys just to make sure it is
still broken.
Now pop Soft-ICE back up with ALT D. Since the bug has already
occurred, we want to restart the program. Enter : EXIT RD. This
command forces the sample program to exit. The R tells Soft-ICE to
restore the interrupt vectors to the state they were when the sample
program was loaded with LDR. The D tells Soft-ICE to delete any
currently pending break points. The R and the D are not necessary in
this case, but it is good to get in the habit of specifying them when
exiting a program that was loaded with LDR.EXE.
You are now back at the DOS prompt. Reload the program by entering :
LDR SAMPLE.EXE
Notice the suffix.EXE was specified this time. When the suffix is
specified, Soft-ICE does not attempt to load a symbol file or source
file. In this case the symbol file and source file are already in
memory. Enter : SYM. This displays the public symbols of the sample
program. Press Esc to get back to the prompt.
We will now set a range break point similar to the one we set while
using Soft-ICE as an assistant to debug. This time we will use symbols
to set the break point. Enter : BPR START .82 W. This will set a range
break point in our code segment from the symbol START to line 82 of
the source file. Enter : BL. You can verify that the break point has
been set properly.
Press ALT D. Press a non-space key. We're back in Soft-ICE. Notice
that the current instruction (the line with the reverse video bar) is
the instruction after the one that caused the break point.
To see the actual code press the F3 key. This places Soft-ICE in mixed
mode. Notice that the reverse video bar covers 2 lines. This is the
actual code line and the source code line of the current instruction.
Press the F3 key again. We are now in code mode. No source lines are
visible. The instruction above the reverse video bar is the
instruction that caused the range break point to go off. Press the F3
key again to get back to source mode.
Now we will fix the bug in the sample program. Exit the sample program
and go back to the DOS prompt by entering : EXIT RD. Re-load the
sample program by entering : LDR SAMPLE. EXE. Set the code window in
code mode by pressing the F3 key twice.
Un-assemble at the broken routine by entering : U not_space.
We will now use the Soft-ICE interactive assembler to fix the problem.
Enter: A not_space. Soft-ICE will prompt you with the address. Enter:
NOP
Press ENTER to exit from the assembler. Notice in the code window that
there is a NOP instruction in place of the CS over-ride at offset
003BH. Press the F3 key to get back to source mode, (the source code
of course is not modified). Press ALT D to run the mended sample
program. Enter spaces and some non-spaces characters. It works! You
fixed the bug! To get out of Jed's program, and return to DOS, press :
CTRL C
Now we're going to demonstrate another feature of Soft-ICE. Enter :
LDR SAMPLE.EXE. This will load the sample program in one more time.
Enter : RIP HANG_EXAMPLE
The first two displayed instructions are:
CLI
JMP $
Notice that the jump instruction jumps to itself. This infinite loop
would normally hang the system in an unrecoverable fashion. Enter :
BREAK ON. We have just turned on BREAK mode. BREAK mode will cause the
system to run slightly slower, but will allow Soft-ICE to come up even
when the system would normal be hung.
Exit from Soft-ICE by pressing ALT D. Your system is now hung. For
those non-believers, press : CTRL ALT DEL
Nothing happens! It is definitely hung. Now press ALT D. The Soft-ICE
window is back! To get out of the infinite loop, enter : EXIT RD. You
are now back at DOS. Try a few directories to get a feel for the
performance degradation. Many people feel comfortable leaving BREAK ON
as a configuration default.
Turn BREAK mode off again by entering : BREAK OFF. Do a few
directories to get a comparison of the speed. That's it! Have fun!
It's time to start experimenting and debugging on your own. Browse
through the rest of the manual and refer to specific sections when
necessary.
