Instruction Set

Instruction Set

---

Format of a Standard Assembler Program

DOSSEG
.MODEL SMALL
.STACK 4096

.DATA
; data definitions

.CODE
ProgramStart:
; assembler instructions

mov ax,SEG _DATA ; set up data segment
mov ds,ax

mov ah,4ch ; terminate program
int 21h

END ProgramStart

This is only valid for simple assembler programs that are of the small, non-memory resident variety. For larger programs the .MODEL directive can be LARGE or HUGE or COMPACT. The .STACK directive indicates the number of bytes to reserve for the stack of the program. If this number is omitted, the stack defaults to 1k.

Except for the commands to terminate the program, all the other commands are what is termed Assembler Directives. These instruct the assembler on how to assemble the program, without generating any actual assembler code.

All names that are used in the program are converted into memory locations during the assembly process. Thus, any name is generally considered to be analogous to a memory location while writing assembly code.

Data definitions

Within the .DATA section, data items can be defined together with initial values. All declarations are of the form:

Name

DataType

Value

The Name is used to refer to the data thereafter. The DataType can be either DB (byte) or DW (word). This defines what the assembler should consider as the data type of the first item of data. All other items of data on that line inherit the same data type. There are a number of other data types but DB and DW are the most common. Value can be used to set an initial value/s for the data item. This can be set to "?" to instruct the assembler that no specific value need be assigned to that data item.

The MOV instruction

The MOV instruction is the most important command in the 8086 because it moves data from one location to another. It also has the widest variety of parameters; so it the assembler programmer can use MOV effectively, the rest of the commands are easier to understand.

format:
MOV destination,source

The possible combinations of operands are as follows :

destination	source	example
register	register	mov ax,bx
register	immediate	mov ax,10h
register	memory	mov ax,es:[bx]
memory	immediate	mov aNumber,10h
memory	register	mov aDigit,ax

MOV copies the data in the source to the destination. The data can be either a byte or a word. Sometimes this has to be explicitly stated when the assembler cannot determine from the operands whether a byte or word is being referenced.

The MOV instruction has a few limitations:

• an immediate value cannot be moved into a segment register directly (i.e. mov ds,10)
• segment registers cannot be copied directly (i.e. mov es,ds)
• a memory location cannot be copied into another memory location (i.e. mov aNumber,aDigit)
• CS cannot be copied to (i.e. mov cs,ax)

These limitations can be overcome using indirect data movement through a general purpose register as illustrated in the general format given above.

Each of the possible values for the destination and source is called an address. From the above table it becomes apparent that there are a number of different addressing modes (immediate, register, memory).

Addressing Modes

1. Immediate Addressing
   This is when a constant value is moved into a register or memory location. It is not really an address since it does not point to any location within the memory or CPU. Immediate addressing can only be used for the source since immediate values are not themselves stored anywhere; during assembly of the program, the immediate value becomes part of the machine code instruction.
   example: mov ax,10h
2. Register Addressing
   A register can be used as both the source and destination of the instruction. Registers are very fast for most operations so maximum use must be made thereof.
   examples:
   mov ax,bx
   mov ax,10h
   mov si,es:[bx]
3. Direct Memory Addressing
   A memory location can be used by using its address as the operand in an instruction.
   example: mov ax,aDigit
   
4. Register Indirect Addressing
   Instead of specifying the memory location as an operand, the memory location can be stored in a register. Then this register must be specified to access the memory. For indirect addressing, the 8086 can only use the BX, BP, SI and DI registers.
   example: mov ax,[bx]
   Note that the difference between this and Register Addressing is the use of the square brackets ([]) which distinguish a normal register from a memory location.
   
5. Base Relative Addressing
   A possible combination of direct and indirect addressing techniques could be when an indirect address is specified as well as an offset from that value. To specify base relative addressing, the programmer must indicate the base register and displacement/offset as a sum.
   examples:
   mov ax,[bx+4]
   mov ax,[bx]+4
   mov ax,4[bx]
   All these instructions will use the same address, which is 4 more than the address stored in the bx register. The only registers allowed are BX and BP (the so-called "base" registers). This technique can also called Direct Indexed Addressing, when it utilises the SI and DI registers (the so-called "index" registers).
   
6. Base Indexed Addressing
   This is a combination of base register and direct indexed addressing. Instead of specifying the address as being stored in one register, the CPU can add the values stored in two registers to get the effective address. Of course, an offset can also be specified. Since this technique uses a base register and an index register, there are only four allowed combinations of registers.
   example:
   mov ax,[bx+si+4]
   mov ax,[bx][si]+4
   mov ax,[bx][si+4]
   All these instructions will use the same address. If BX=4 and SI=8, then the address will be 4+8+4 =16 (decimal) = 10h.
   Base indexed addressing is useful for indexing two-dimensional arrays, whereas the other methods are used for the simpler one-dimensional cases.
   

Complete Table of Addressing Modes

displacement only

BX + displacement

BP + displacement

SI + displacement

DI + displacement

BX + SI + displacement

BX + DI + displacement

BP + SI + displacement

BP + DI + displacement

Example usage of non-trivial addressing modes

Index registers can be used just like array indices in high-level languages. Assume that an array of bytes is stored in memory at location anArray. Then, to access the second element, we need to use the address anArray+1. To access the second element, we use anArray+2 ... etc. In order to access an arbitrary element we can use a variable index eg. BX. Thus we need to index anArray+BX. Written in assembler, this translates to anArray[BX] or [anArray+BX] or [BX]+anArray.

Segment Over-riding

Instead of all references to memory being taken from the DATA segment, the programmer can explicitly tell the assembler to read a memory location using a different segment. To do this, the name of the segment must be prepended with a ':' to the address.

example: mov ax,ex:[bx]

This calculates the effective address using the ES register instead of the DS register which is normally used. Similarly, the CS register can be overridden when required. This is normally used when a memory location in another segment needs to be accessed. Rather than change the DS register unnecessarily, ES could be used for that purpose.

The Stack

The 8086 uses a simple stack in memory for the storage of temporary data. It also uses this stack to store the return addresses when it enters a new procedure. All values on the stack are 16-bit words. The registers that manage the stack are SS, SP and BP.

• SS denotes the segment of the stack
• SP (stack pointer) points to the last element on top of the stack
• BP (base pointer) points to the bottom of the stack. This is used to set up and manage information on the stack during a procedure call.

The stack grows downwards during its typical operation. This means that when more elements are added to the top of the stack, the value of SP decreases. When the stack is set up, SP points to the largest value on the stack. For the sample code at the beginning of the chapter (.STACK 4096), SP would be set to point to 4094 at the beginning of the program - 4094 is two bytes from the end of the stack, which is at location 4095 since all segments start at location 0.

There are a few commands which allow the programmer to store and retrieve values from the stack.

The PUSH/POP instructions

format:
PUSH source
POP destination

The possible operands are as follows :

source	example
register	push ax
pop ax
memory	push es:[bx]
pop es:[bx]

PUSH decrements the SP register (by 2) and copies a value onto the top of the stack. POP retrieves the value from the top of the stack and stores it into the destination, then increments the SP register (by 2).

PUSH and POP can be used to save and restore the values of registers when the register needs to be used for some other function temporarily.

example:
push ax
mov ah,09h
mov dx,OFFSET aMessage
int 21h
pop ax

Here the value of AX is probably crucial but AX has to be used in order to output a message. So its contents are saved on the stack and restored after the interrupt procedure is called.

The LEA instruction

format:
LEA register,memory

Load Effective Address loads the specified register with the offset of a memory location.

The following two lines of code are identical:

mov ax,OFFSET aMessage
lea ax,aMessage

However, the MOV instruction cannot be indexed because OFFSET is an assembler directive, not an instruction. It would be impossible to say

mov ax,OFFSET aMessage+[BX]

since the offset calculation is done at assembly-time. On the other hand, it is possible to issue the command

lea ax,aMessage[BX]

example:

lea dx,aMessage
mov ah,09h
int 21h

Notice that this is the same standard method of outputting a string to the screen. It is preferred to use the LEA instruction in such situations, making offsetting of the string easier in future.

Flags

The flags are a set of variables in the CPU which indicate the status of various calculations and components of the CPU. Flags are used, among others, in the following contexts:

• to indicate errors
• to indicate the sign of the last calculation
• to enable a carry during arithmetic operations
• for debugging

A number of instructions perform certain tasks based on the current state of the flags. The most commonly used flags are:

CF	carry flag
ZF	zero flag
SF	sign flag
OF	overflow flag
IF	interrupt enable flag
DF	direction flag

The PUSHF/POPF instructions

format:
PUSHF
POPF

These instructions save and restore all the flags to/from the stack. This preserves the flags when the code about to be executed is going to modify crucial flags.

example:
pushf
call bigadd ; call procedure
popf

External/Public assembler directives

In order to incorporate procedures written in separate files, the programmer needs to include PUBLIC directives in the procedure file and EXTRN directives in the main program file. The secondary procedure file need not have a program entry point since it cannot be used on its own. Assuming that a procedure called readsint has been defined to read an integer into the AX register. This procedure is then exported by including the following line at the top of the code in the secondary file:

PUBLIC readsint

Similarly, the program that is going to use this procedure must include a statement telling the assembler that it is going to use a procedure from an external file. To do this, the following line must be included at the top of the main program source file:

EXTRN readsint:proc

Multiple declarations can be separated by commas
eg. EXTRN readsint:proc,writesint:proc

After both files are assembled separately, the files must be linked together with a command such as:

TLINK MAIN.OBJ SECOND.OBJ

The IOASM library provides the following two procedures that can be incorporated into your programs to make input and output simpler:

readsint - reads an integer into the AX register

writesint - writes the value of the AX register to standard output

To link your programs with IOASM, you need to include the following line at the top of your program:

EXTRN readsint:proc, writesint:proc

and then link the program with the command TLINK YOURFILE IOASM.LIB

Sample Program #4

; simple numerical output program
DOSSEG
.MODEL SMALL
.STACK 4096

.DATA
Number1 dw 12
Number2 dw 24
Number3 dw 36

.CODE

EXTRN writesint:proc
; use procedure from IOASM to output number to screen

ProgramStart:
mov ax,SEG _DATA
mov ds,ax

mov bx,Number1 ; illustrate MOV instruction
mov ax,bx
call writesint ; call procedure to output number

mov ax,Number2 ; illustrate PUSH/POP instructions
mov bx,ax
push bx
mov ax,0
call writesint ; call procedure to output number
pop ax
call writesint ; call procedure to output number

mov ah,4ch
int 21h
END ProgramStart

This program simply loads a memory location into the AX register and outputs it using the procedure built into the IOASM library. The second part of the program loads a value into the AX register and then pushes this value onto the stack. The AX register is cleared and the value is popped off the stack. The point of this exercise is to prove that the stack really does preserve the value put onto it.

The ADD instruction

format:
ADD destination,source

The legal operand combinations are as follows:

destination	source	example
register	immediate	add ax,10
register	register	add ax,bx
register	memory	add ax,es:[bx]
memory	register	add es:[bx],ax

ADD adds the contents of the source to the destination. The source and destination may be either bytes or words but both operands must be the same type or the assembler will generate an error. If the sum of the two numbers cannot fit in the destination, an extra bit is required and this is signalled by the ADD operation setting the carry flags (CF) to 1. If the sum fits without spillage, CF=0. Other registers can be affected by addition operations as well; ZF=0 if the sum is zero, SF=1 if the sum is negative, etc. The logic of the basic addition command is:

destination = destination + source

In the case where a carry bit is being introduced into the calculation from a previous calculation, the ADC instruction must be used instead of ADD, and the logic is:

destination = destination + source + carry

The SUB instruction

format:
SUB destination,source

The legal operands combinations are the same as for addition.

SUBtracts the source value from the destination. Operation is almost identical to addition, except that the CF flag is used as a borrow in the case of the SBB (subtract with borrow) instruction. The logic of the SUB instruction is:

destination = destination - source

and the logic of the SBB instruction is:

destination = destination - source - carry

The INC/DEC instructions

format:
INC destination
DEC destination

INC increments the source by one. Rather than use an ADD to increment a register or memory location, the INC instruction does the job faster and takes only parameter. Similarly, DEC decrements the source by one. These are an example of the many instructions that can be replaced by a sequence of other instructions; they are used to speed up common operations.

The MUL instruction

format:
MUL source

MUL multiplies the source with the accumulator. If the source is a byte-register or memoy location, the other element used in the multiplication is the AL register - the product is then stored in the AX register. If the source is a 16-bit word, the AX register is automatically used as the second parameter and the product is stored in the DX:AX register pair. This means that the DX register holds the high part and the AX register holds the low part of a 32-bit number.

The DIV instruction

format:
DIV source

DIV divides the accumulator by the source (which is used as the divisor). If the divisor is a byte-register of memory location, the AX register is used as the dividend and quotient is stored in the AL register - the remainder is stored in the AH register. If the divisor is a word, the DX:AX 32-bit register pair is used as the dividend and the quotient is stored in the AX register - the remainder is stored in the DX register.

The DIV instruction must be used very carefully because of the potential risks of dividing by zero. If the divisor has a value of zero, the CPU generates a "Divide by zero" interrupt which, in most cases, will cause the computer to halt the executing program (at the very least).

Sample Program #5

; simple numerical calculation program
; calculate (x^3 + 4) mod y

DOSSEG
.MODEL SMALL
.STACK 4096

.DATA

Number1 dw ?
Number2 dw ?
Four dw 4 ; constant
crlf db 13,10,'$' ; carriage return/linefeed

.CODE

EXTRN readsint:proc,writesint:proc
; use procedure from IOASM to output number to screen

ProgramStart:
mov ax,SEG _DATA
mov ds,ax

call readsint ; read in X
mov Number1,ax
lea dx,crlf
mov ah,09h
int 21h

call readsint ; read in Y
mov Number2,ax
lea dx,crlf
mov ah,09h
int 21h

mov ax,Number1 ; X
mov dx,0
mul Number1 ; X*X
mul Number1 ; X*X*X
add ax,Four ; X*X*X + 4
div Number2 ; (X^3 + 4) div Y

mov ax,dx ; output remainder
call writesint
lea dx,crlf
mov ah,09h
int 21h

mov ah,4ch
int 21h
END ProgramStart

This programs inputs two variables (X and Y) and calculates the value of the expression:

(X^3 + 4) mod Y.

The AND instruction

format:
AND destination,source

The legal operands for this instruction are the same as those for the ADD instruction.

AND performs a bitwise AND on the source and destination operands and stores the result in the destination operand. It is useful to check the various bits in a particular byte/word.

example:
and ax,0008h

After this instruction, AX will be greater than 0 only if bit 3 is set.

example:
and ax,FFF7h

In this case, the AND instruction can be used to clear bit 3.

The OR instruction

format:
OR destination,source

The legal operands are the same as for ADD. OR performs a bitwise OR on the source and destination and stores the result in the destination.

example:
or ax,0008h

This sets bit 3 in the AX register.

The XOR instruction

format:
XOR destination,source

Performs an Exclusive-OR operation on the source/destination and stores the result in the destination register.

example:
xor ax,bx
xor ax,ax

The second example is an interesting, faster than usual, method of clearing a register.

The SHR/SLR instructions

format:
SHR destination,1
SHR destination,CL
SHL destination,1
SHL destination,CL

SHR shifts the destination right bitwise either 1 position or a number of positions determined by the current value of the CL register. SHL shifts the destination left bitwise either 1 position or a number of positions determined by the current value of the CL register. The vacant positions are filled by zeros.

example:
shr ax,1
shl ax,1

The first example effectively divides ax by 2 and the second example effectively multiplies ax by 2. These commands are faster than using DIV and MUL for arithmetic involving powers of 2.

Sample Program #6

; simple numerical calculation program
; calculate (x and y) / 32

DOSSEG
.MODEL SMALL
.STACK 4096

.DATA
x dw ?
y dw ?
Five db 5 ; constant
crlf db 13,10,'$' ; carriage return/linefeed

.CODE

EXTRN readsint:proc,writesint:proc
; use procedure from IOASM to output number to screen

ProgramStart:
mov ax,SEG _DATA
mov ds,ax

call readsint ; read in X
mov x,ax
lea dx,crlf
mov ah,09h
int 21h

call readsint ; read in Y
mov y,ax
lea dx,crlf
mov ah,09h
int 21h

mov ax,x ; X
and ax,y ; X and Y
mov cl,Five
shr ax,cl ; (X and Y) / 32

call writesint ; output result
lea dx,crlf
mov ah,09h
int 21h

mov ah,4ch
int 21h
END ProgramStart

This program is very similar to the previous example. The difference is that the formula being evaluated is (x and y) / 32. The division is implemented as a SHR rather than a DIV.

The JMP Instruction

format:
JMP target

Unconditionally jumps immediately to the next instruction following the target label. This is used to generate loops and perform selection within an assembly language program.

example:
start:
lea dx,aMessage
mov ah,09h
int 21h
jmp start

This piece of code will output the message and then jump back to the top of the code and repeat its action. It will, in fact, produce an endless loop with messages being written to the screen.

The CMP Instruction

format:
CMP destination,source

Compare the numerical value of the destination with the source and set flags appropriately. This comparison is carried out in the form of a subtraction to determine which of the operands has a greater value. After a CMP instruction, OF, SF, ZF and CF are set appropriately. For example, if the operands have equal values, then ZF if set.

These flags can then be interpreted by the various conditional JUMP instructions and decisions can be taken on that basis.

The JUMP Instructions

example format:
JE target

The conditional jump instructions will execute a jump on the basis of the previous CMP instruction. The operation of the flags can be virtually transparent if meaningful names are used for the jump instruction. For example, JE will jump if the previous comparison yielded an equality. JNE will jump if the previous comparison was unequal. If the jump is not executed, the following instruction is executed as normal.

JA	jump if destination above source
JAE	jump if destination above or equal to source
JB	jump if destination below source
JBE	jump if destination below or equal to source
JE	jump if destination equals source
JNE	jump if destination not equal to source

There are many more jump instructions but most situations will be covered by those above.

Conditional Jump instructions can only jump to a location that is physically within 128 bytes of the point from where the jump is taking place. This means that the jump must be to a nearby location. JMP has no such limits so the two instructions can be used in tandem to write effective decision-making algorithms in assembler.

example:
cmp ax,bx
je thenpart
elsepart:
mov cx,2
jmp endpart
thenpart:
mov cx,1
endpart:

This is equivalent to the following line of pascal code:

if (ax=bx) then cx:=1 else cx:=2;

This can be expanded to simulate the equivalent of a pascal "case" statement.

Procedures

Procedures in assembly language are declared with a PROC directive at the beginning and an ENDP directive at the end.

example:
TestProc PROC
mov ax,0
ret
TestProc ENDP

All procedures have a RET instruction at the end. This restores control to the point after which the procedure was called in the main program body.

After declaring the procedure, it can be called with a CALL instruction.

example:
CALL TestProc

The CALL instruction saves the address of the next instruction onto the stack and then changes the IP to reflect the value of its parameter. Since the IP keeps track of the currently executing instruction, this change causes the program to jump to the beginning of the procedure. When the RET instruction is encountered, it pops the old IP value off the stack, thus causing procedure to return to the main program body.

The CALL instruction can also take a register or memory location as a parameter. In this situation, the register/memory location contains the address of the procedure to be called.

FAR/NEAR type modifiers

In certain cases, procedures are defined in segments other than the one from which the procedure is called. In this case, simply saving the IP will not be enough to remember the point of calling; the segment has to be saved as well. The definition of the procedure must be changed to reflect that it is a FAR (meaning: not in same segment) procedure.

TestProc PROC FAR
mov ax,0
ret
TestProc ENDP

To call a procedure that is known to be in another segment, the CALL statement can also be modified using a FAR type modifier. example:
CALL far ptr TestProc

Sometimes, it helps to explicitly define a procedure as NEAR (meaning: in the same segment) to create smaller programs. The unconditional JMP instruction can also take such FAR/NEAR type modifiers.

BYTE/WORD type modifiers

These modifiers are used to explicitly state whether a memory location stores a byte or a word. It is used in cases where the assembler cannot determine from the parameters whether a byte or word should be stored or referenced.

example:
mov ax,word ptr ES:BX

Sample Program #7

TestProc PROC
mov ax,4
ret
TestProc ENDP

ProgramStart:
mov ax,SEG _DATA
mov ds,ax

mov ax,5
call writesint

call TestProc
call writesint

This program demonstrates how to define and call a procedure. The top and bottom portions of the program have been omitted from the listing as they are fairly standard.

Sample Program #8

mov ax,11h

jmp Label3

Label1:
cmp ax,11h
jne TheEnd
mov ax,1
jmp TheEnd

Label2:
mov ax,2
jmp TheEnd

Label3:
cmp ax,10h
je Label2
jmp Label1
mov ax,3

TheEnd:
call writesint

This program shows how control can be transferred within the program depending on the values of a register.

The LOOP instruction

format:
LOOP target

Analogous to the "for" instruction in pascal is the LOOP instruction in assembler. The LOOP instruction runs a loop for a pre-specified number of iterations. The CX register is used to contain the number of iterations. Each time the LOOP instruction is encountered, it decrements CX and checks if it has reached zero. If it has, then control goes to the following instruction; if not, a jump is made to a specified point.

example (for):
mov cx,10
xor ax,ax
addstart:
add ax,cx
loop addstart:

This simple loop finds the sum of the first ten numbers using an iterative technique. In order to write loops analagous to the "while" or "repeat" pascal statements, it is advisable to use a CMP instruction coupled with an appropriate conditional jump.

example (repeat):
mov cx,10
xor ax,ax
addstart:
add ax,cx
dec cx
cmp cx,0
jne addstart

example (while):
mov cx,10
xor ax,ax
addstart:
cmp cx,0
je addend:
add ax,cx
dec cx
jmp addstart
addend:

The INT instruction

format:
INT num

INT calls the relevant interrupt procedure as specified by the num parameter. Any DOS or BIOS software interrupt can be called using the INT instruction. Sometimes it may be necessary to set certain values into specific registers to pass parameters to the interrupt routine.

example:
INT 21h

21h is the most common interrupt because it provides input and output services to DOS programs.

The structure of an interrupt procedure is like any normal procedure as far as the assembler is concerned. However, when performing an INT, the 8086 does a number of additional tasks, like saving the flags. Thus, instead of a RET instruction at the end of the procedure, every interrupt routine has an IRET instruction at the end. This IRET does the additional processing required (viz. restoring the flags) before returning control to the calling program.

The NOP Instruction

NOP (No OPeration) takes no parameters and does nothing. It is normally used for debugging only.

The MOVSB/MOVSW Instructions

example format:
REP MOVSB
REP MOVSW

These instructions are used to copy a block of bytes/words from one location in memory to another. The source is pointed to by DS:SI and the destination is pointed to by ES:DI. These register pairs are the only ones that can be used with string instructions such as MOVSB/MOVSW.

The REP prefix is used in conjunction with the actual instruction to repeat the MOV operation for the length of the block; it is similar to the LOOP instruction. In order to use REP, CX must first be set to the number of elements (bytes/words) in the block.

example:
mov cx,100
lea si,Source
lea di,es:Dest
cld
rep movsb

CLD clears the direction flag. This tells the 8086 that it must increment the SI and DI register after each iteration. If the direction flag is set instead of being cleared (using STD) then the 8086 will decrement SI and DI after each iteration. This creates the effect of copying a block in reverse.

Other Instructions

CMPS	compares two string in memory
SCAS	scans a string for an element
LODS	loads an element from a string
STOS	stores an element into a string

IN	inputs a value from a hardware port
OUT	outputs a value to a hardware port

AAA	ascii adjust for addition
AAD	ascii adjust for division
AAM	ascii adjust for multiplication
AAS	ascii adjust for subtraction
CBW	convert byte to word
CWB	convert word to doubleword
DAA	decimal adjust for addition
DAS	decimal adjust for subtraction

CLC	clear carry flag
STC	set carry flag
CLI	clear interrupt flag
STI	set interrupt flag
CMC	complement carry flag
DAA	decimal adjust for addition
DAS	decimal adjust for subtraction

JCXZ	jump if CX equals zero
JG	jump if greater
JGE	jump if greater or equal
JL	jump if less
JLE	jump if less or equal

LDS	load pointer using DS
LES	load pointer using ES
LOOPE	loop while equal
LOOPNE	loop while not equal

NEG	negate
NOT	logical NOT

ROL	rotate left
ROR	rotate right

REPE	repeat while equal
REPNE	repeat while not equal

XCHG	exchange two operands
XLAT	translate using table