CSCI 2150 -- Laboratory Experiment
Introduction to Borland's Turbo Debugger
and 80x86 Assembly Language

The software we will be using today, the Borland Turbo Debugger, is very old technology (circa 1988), but it does work. More importantly, it offers the newcomer to the 80x86 architecture and its associated assembly language programming an inside look at the 80x86 processor. It runs from DOS, so if your computer is not running in DOS mode, restart windows in DOS mode now or select "Command Prompt" from the Accessories menu.

Once you get to the command prompt screen, all commands will be entered with text strings. Turbo Debugger (TD) is located in the directory C:\TD on your machines. Change to this directory now by first verifying that you are in the C-drive (type C: and return if you are not), then using the DOS command CD\TD. Your command prompt should now look like C:\TD>. Start the debugger by typing the command TD. Once you've started TD, you should see a screen similar to the one shown in the figure below.

This opening screen allows the user to view:

• the memory that contains the program;
• memory that contains data;
• the internal registers; and
• the processor condition flags.

The purpose of this lab is to reinforce what we learned during the introduction to microprocessors lecture by running some code in the Turbo Debugger and seeing how the code affects the registers and other microprocessor components. First, let's examine the Turbo Debugger screen. The figure below labels the components of the screen.

Internal Register Window - Let's start with a simple window. The internal register window displays the current values stored in the registers of the microprocessor. Remember, a register is simply a group of latches that when combined store a single value. The code that executes on the processor may use these registers to remember data or address locations. Below is a list of the registers along with their description. Don't worry if the description doesn't help much; just note that each has a different purpose.

• Registers used to process or alter data:
  • AX - Accumulator
  • BX - Base
  • CX - Counter
  • DX - Data
• Registers used to point to specific areas of memory:
  • CS - Code Segment - A register pointing to the area of memory where the code is stored
  • DS - Data Segment - A register pointing to the area of memory where the data is stored
  • SS - Stack Segment - A register pointing to the area of memory where the processor temporarily stores register values in case they get messed up
  • ES - Extra Segment - A register pointing to where ever the user wants it to point

Each of the data registers (AX, BX, CX, and DX) can also be referred to by their low byte or their high byte. This simply means that instead of grouping 16 latches together as a single number, they can also be referenced as two groups of 8 latches. For example, if you want to modify only the low byte of the register AX, you refer to it as AL. This will cause the processor only to alter the lower eight bits. These "sub registers" are labeled as:

The remaining registers are pointer registers:

• IP is the instruction pointer and it contains the address of the next instruction to execute.
• SP is the stack pointer and it points to the "top plate" or last piece of data placed on the stack.
• BP (base pointer), SI (source index), and DI (destination index) are all pointers that the programmer has for their own use.

Assembly Language Window - This window displays to the user information about the code that will be executed. Each line looks something like the following:

The cs indicates that the CS (code segment) register contains the segment where the code is stored. Take the value in CS, shift it left 4 bits (i.e., tag four binary zeros or one hexadecimal zero to the right side of the number), then add the hexadecimal number to the right of the colon to the shifted CS value. This is the physical address of the line of code. For example, if CS = A000₁₆, then CS:10B4 indicates that the physical address that the line of code is stored in is A10B4₁₆.

The user can also determine the next address to be executed from this window. The instruction with the after the address is the next address to be executed. You can also determine this by adding the value in the register IP to CS using the technique above. For example, if CS=B0C0₁₆ and IP=001F₁₆, then the next address to execute would be CS:IP.

The hexadecimal number following the address (8B7604 in the case of our example above) represents the actual binary data that is stored in memory to represent the instruction. In other words, this is the machine code that our assembly language translates to. For those of you who want the specifics, 8B76 means move the value pointed to by the base pointer (BP) along with some offset into the source index (SI) register. The 04 that follows is the offset. This gives us the instruction mov si,[bp+04].

After the hexadecimal instruction value, there is the text representation of the instruction. This text is the assembly language code that the processor will execute.

Data Display Window - This window displays the hexadecimal values of the memory array where the data segment register (DS) is pointing. This is where the program will get its data. Notice once again the use of the segmented addressing with DS as the segment.

Processor Flags - As we discussed last class period, there are bits that are set or cleared in order to indicate the result of a process or to indicate the current state of the processor. As an example, the purpose of three of those bits is shown below.

• C - Carry flag. This bit is set if the result of an arithmetic or logical operation sets the uppermost carry bit. (i.e. an overflow has occurred) It is cleared otherwise.
• S - Sign flag. This bit is set if the result of an arithmetic or logical operation has resulted in a negative number. (2's complement representation) It is cleared otherwise.
• Z - Zero flag. This bit is set if the result of an arithmetic or logical operation has resulted in a value of zero. (i.e., all bits are cleared) It is cleared otherwise.

Lab Procedure

Note that if you do not have mouse control, you can move between windows on the TD screen using the tab key. Use the arrow keys to go between items within a single window.

Modifying Registers

Throughout this lab, you will be asked to change the values in some of the registers. Use the following techniques to do this.

• Tab to the internal register window, then with the arrow key, move the cursor to the AX register. Along the bottom of the screen, there is a menu. If you press the CTRL key, the menu should change to:
  
  Ctrl: I-Increment D-Decrement Z-Zero C-Change R-Registers

• While holding down CTRL, press I to increment and note the change in the register AX.
• While holding down CTRL, press C to change the value of AX. Use the window that appears to change the value of AX to 12F3₁₆. Note that all values are hexadecimal so you do not need to add anything to indicate the base. Just type 12F3. If the number you want to enter begins with a letter such as F342, use a leading zero to indicate that it is a number you are entering. Did AX change?

Loading a Program Into Memory

• Pressing ALT-F will open the file menu. Do this, then select Open.
• From the window that appears, select ex1.exe. If you do note see the ex1.exe file, then make sure you are currently displaying the files from the C:\TD directory. ex1.exe is a very short program that simply increments the register AX.
• Click "Ok" when the error comes up that the program has no symbol table. This will not affect the operation of the debugger.
• The assembly language window should now have the three lines of the program starting at address cs:0000.
  
  
• At this point you should have changed AX to 12F3₁₆. If you haven't, do that now. Also, verify that the triangle symbol is pointing to the line shown in the figure above.
• Once the program is in memory, we can do a number of things with it. For now, let us just step through the program one line at a time. The first instruction tells the processor to move 0000₁₆ into the AX accumulator. Press F7. (F7 executes a single line of code.) Did this happen? What happened to the triangle symbol?
• Press F7 multiple times to see the affect of stepping through the program. What is happening to AX?
• Note that value in IP, the instruction pointer, is following the triangle symbol indicating which instruction is being executed next.
• Let's see how the instruction pointer, IP, affects the next instruction. Tab over to the internal register window and use the arrow keys to move to the IP register. Using the CTRL key, bring up the register modify menu and select Z to zero or clear the IP register. What happened to the triangle symbol?
• Press F7 to get the code to execute a few instructions again to see that the program basically started from scratch.

Watching the Processor Flags

We also have access to the processor's flags. The next few steps will show you how they are affected.

• At this point, the S flag should be zero indicating that the last operation resulted in a positive number. Tab to the internal registers window, select the AX register, press CTRL to bring up the modify menu, and select change. Load AX with the value 7FFF₁₆. Press F7 to step through the program until after you execute the instruction "inc ax". This should have changed 7FFF₁₆ to 8000₁₆ (a positive number to a negative number). What happened to the S flag? Why?
• Let's experiment with the zero flag now (Z). Load AX with the value FFFF₁₆. (This is hexadecimal for -1). Press F7 to step through the program until after you execute the instruction "inc ax". This should have changed FFFF₁₆ to 0000₁₆ (a change to zero). What happened to the Z flag? Why?

We're done! To quit Turbo Debugger, press ALT-F to open the file menu and Q to quit.

Developed by David Tarnoff for the Spring 2003 sections of CSCI 2150 at ETSU