11/3/2020
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
1/25
11/3/2020
Instruction Set
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
register
register
register
source
register
immediate
memory
example
mov ax,bx
mov ax,10h
mov ax,es:[bx]
memory
memory
immediate
register
mov aNumber,10h
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
2/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
3/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
4/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
5/25
11/3/2020
Instruction Set
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 :
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
6/25
11/3/2020
Instruction Set
source
example
register
push ax
memory
pop ax
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
7/25
11/3/2020
Instruction Set
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
ZF
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
carry flag
zero flag
8/25
11/3/2020
Instruction Set
SF
OF
IF
sign flag
overflow flag
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
9/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
10/25
11/3/2020
Instruction Set
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
register
register
source
immediate
register
example
add ax,10
add ax,bx
register
memory
memory
register
add ax,es:[bx]
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
11/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
12/25
11/3/2020
Instruction Set
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
Number2
Four dw
crlf db
dw ?
dw ?
4 ; constant
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
13/25
11/3/2020
Instruction Set
mov ah,09h
int 21h
mov
mov
mul
mul
add
div
ax,Number1 ; X
dx,0
Number1 ; X*X
Number1 ; X*X*X
ax,Four ; X*X*X + 4
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
14/25
11/3/2020
Instruction Set
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.
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
15/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
16/25
11/3/2020
Instruction Set
mov ah,09h
int 21h
mov
and
mov
shr
ax,x ; X
ax,y ; X and Y
cl,Five
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
17/25
11/3/2020
Instruction Set
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
JAE
JB
JBE
JE
JNE
jump if destination above source
jump if destination above or equal to source
jump if destination below source
jump if destination below or equal to source
jump if destination equals source
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 decisionmaking algorithms in assembler.
example:
cmp ax,bx
je thenpart
elsepart:
mov cx,2
jmp endpart
thenpart:
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
18/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
19/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
20/25
11/3/2020
Instruction Set
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.
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
21/25
11/3/2020
Instruction Set
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
22/25
11/3/2020
Instruction Set
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
SCAS
LODS
STOS
compares two string in memory
scans a string for an element
loads an element from a string
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
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
23/25
11/3/2020
Instruction Set
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
STC
CLI
STI
CMC
DAA
clear carry flag
set carry flag
clear interrupt flag
set interrupt flag
complement carry flag
decimal adjust for addition
DAS decimal adjust for subtraction
JCXZ jump if CX equals zero
JG
jump if greater
JGE
JL
JLE
jump if greater or equal
jump if less
jump if less or equal
LDS
LES
LOOPE
LOOPNE
load pointer using DS
load pointer using ES
loop while equal
loop while not equal
NEG negate
NOT logical NOT
ROL rotate left
ROR rotate right
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
24/25
11/3/2020
Instruction Set
REPE repeat while equal
REPNE repeat while not equal
XCHG exchange two operands
XLAT translate using table
www.husseinsspace.com/teaching/udw/1996/asmnotes/chaptwo.htm
25/25