Compared with the VSC the x86 family of microprocessors have an extensive set of registers.  They have a minimum of 14 internal 16-bit registers, some of which can be accessed as two different 8-bit registers.  For example AX, BX, CX and DX are word (16-bit) registers.  AL, AH, BL, BH, CL, CH, DL and DH are byte (8-bit) registers.  The L means low byte and and H means high byte.  Actually AX through DX are each made up of the register pairs (AL,AH) through (DL,DH). There are 10 more registers that are each 16 bits.

Assembly language uses mnemonics which are short strings representing machine language instructions.  Assembly programs are made of lists of mnemonics and operands as shown in the examples below:

We will investigate the CPU using a simple version of machine lanugage programs called .COM files.  These files are created using the utility program DEBUG.  This program allows you to write, edit, trace, load and save 80x86 assembly programs.

Step 1: Open an MS-DOS prompt window, go to the directory containing the DEBUG program (this could be C:\windows\command).  From the command console (once you are in the correct directory), run the DEBUG utility by typing its name at the prompt and pressing the <Enter> key.

-A100

Step 3:  Enter the following program (press enter at the end of each line)

MOV DL, 24
MOV AH, 2
INT 21
INT 20

Step 4: Now enter

G

Step 5:  Type Q and press <Enter> to quit DEBUG.

Let's take a closer look at what this program is doing. The program loads the DL register with 24 hex.  All numbers in DEBUG are hex by default.  The ASCII value of the symbol $ is 24 hex.  Then the program places the value 2 in the AH register.  The DOS operating system and its legacy as provided in the Win32 OS family supports the DOS interrupt INT 21.  This interrupt checks the value in AH to see what action is to be performed.  The 2 instructs the processor to run a section of code to print a character to the screen memory.  Finally the INT 20 causes an exit (ends the .COM program)

From the DEBUG utility you can check the values of the registers using the R command. Run DEBUG and enter -R at the dash. You should see a list of register names and hex values for each.

You can view any portion of memory using the U command.  To view a page of the contents of memory at a particular location simply enter the command followed by the starting address

-U100

Notice that the upper 16 bits of the address is assumed to be the current address.  We can specify any other location in memory by including the complete address

-U 1234:1234

You can also specify a range of addresses by including the starting and ending address separated by commas.

-U 1000, 1010

When using the U command every word is interpreted as an assembly language instruction.  When the contents of a memory address cannot be interpreted as an instruction the U command displays questions marks ???.  Alternatively we can view the contents of memory as data (in hex) by using the D command.

-D100

Each pair of hexadecimal digits is one byte, and each line shows 16 bytes. Note that the address changes by 10 hex or 16 decimal.  The block on the right-hand side shows the equivalent ASCII symbol for each byte in the range 0..127 decimal.
 

If you wanted to print messages to the screen it would be rather cumbersome to print one character at a time. Instead we can Set AH=9 to instruct the DOS interrupt INT 21 to print an entire string.

100 MOV AH,9
102 MOV DX,109
105 INT 21
107 INT 20
109 DB 'This is a sample string.$'

You can invoke a carriage return using the ASCII value 10 (A hex) and a linefeed using the ASCII value 13 (D) as shown below,

100 MOV AH,9
102 MOV DX,109
105 INT 21
107 INT 20
109 DB 'This is',A,D,'a sample string.$'

To place the number 9 hex into offset address 200 hex, we load the address 200h into BX, load the value 9 into AL and the transfer the value AL into the memory location pointed to by BX.

MOV BX, 200
MOV AL, 09
MOV [BX], AL
INT 20

Now try this.

The DEBUG program can be saved to the hard drive by following the procedure outlined below:
 

1. Set the BX register to 0.

2. Set the CX register to the number of bytes contained in the program.

3. Use the N command to name the program.

4. Use the W command to write the program to the hard drive.

The BX and CX registers can be set to any value by using the R command.  Typing the command

RBX

causes the DEBUG utility to display the contents of this register and wait for you to enter a new value.  To keep the present value just press the <Enter> key.  Otherwise enter the new value.  In this case you will want to enter a 0 value.

Next set the CX register to the number of bytes contained in the program being saved.  You can set this register to a value that is larger than the program size but this is not recommended.

Now set the name of the program to be saved using the N command

-Ntest.com

You can save .COM files to the A: drive by including the drive letter as part of the file name.

-NA:test.com

Finally you can write the file to the designated drive by using the W command.  To retrieve the saved program set the name and then enter L (load command).
 

Write and run the mystery .COM program below and then use the <Cntrl><Break> command to interrupt it.  For Windows 2000 you can stop the program with a <Cntrl> C.  If you touch any other key you may have to close the console window to interrupt this program.

100 MOV AH,2
102 MOV DL,24
104 INT 21
106 JMP 104

-RIP
100

You can specify a breakpoint to stop the program by including the breakpoint address following the G command.

-G 102

When the breakpoint is reached the values of the registers are displayed to support diagnostics.   Setting breakpoints is a good way to view the contents of the registers before they are reset on exit.