UNIT – II: 8086 PROGRAMMING

Program Development Steps:

Major steps in developing an assembly language program

• Defining the Problem

• Representing program operations
• Finding the right instructions
• Writing a program
Defining the problems

A
• Find out the problem.
For example: Sensing temperature, detecting fire, detecting smock, decoder-encoder,

PT
Intelligent machine controller etc.

Representing program operations

• Formula or sequence of operations used to solve a programming problem is called as the
algorithm.
• There are two ways of representing algorithms:
- Flowchart
U
G
- Structured programming and pseudo code
Finding the right instructions
U
• Instructions in 8086 are mainly divided into following categories
• Data Transfer Instructions
AN

• Arithmetic Instruction
• Bit manipulation Instruction
• String Instruction
• Program execution transfer Instruction
H

• Processor control Instruction

Writing a program
.B

• We need to do the following steps to write the program effectively:

- INITIALIZATION INSTRUCTIONS: used to initialize various parts of the program like
segment registers, flags and programmable port devices.
G

- STANDARD PROGRAM FORMAT: it’s a tabular format containing ADDRESS, DATA

OR CODE, LABELS, MNEM, OPERAND(S) and COMMENTS as the columns.

1
 - DOCUMENTATION: you should document the program. E.g. each page of the document
contains page number and name of the program, heading block containing the abstract about
the program, comments should be added wherever necessary.

Instruction Set of 8086:

The 8086 instructions are categorized into the following main types.
a. Data Copy / Transfer Instructions
b. Arithmetic and Logical Instructions
c. Branch Instructions

A
d. Loop Instructions
e. Machine Control Instructions

PT
f. Flag Manipulation Instructions
g. Shift and Rotate Instructions
h. String Instructions

a) Data Transfer Instruction:

U
G
These types of instructions are used to transfer data from source operand to destination operand.
All the store, load, move, exchange, input and output operations belong to this category.
b) Arithmetic and Logical Instructions:
U

All the instructions performing arithmetic, logical, increment, decrement, compare and scan
instructions belong to this category.
AN

c) Branch Instructions:

These instructions transfer control of execution to the specified address. All the call, jump,
interrupt and return instructions belong to this category.
H

d) Loop Instructions:

The LOOP, LOOPNZ and LOOPZ instructions belong to this category. These are useful to
.B

implement different loop structures.

e) Machine control Instructions:
G

These instructions control the machine status. NOP, HLT, WAIT and LOCK instructions belongs to
this category.

2
 f) Flag Manipulation Instructions:
All instructions which directly affect the flag register belong to this category. The instructions
CLD, STD, CLI, STI etc. belong to this category.
g) Shift and Rotate Instructions:

These instructions involve the bitwise shifting or rotation in either direction with or without a
count in CX.
h) String Instructions:

These instructions involve string manipulation operations like load, scan, compare, store etc. These
instructions are only to be operated upon the string.

A
a) Data Copy / Transfer Instructions: -
MOV:

PT
This instruction copies a word or a byte of data from some source to a destination.
The destination can be a register or a memory location. The source can be a register, a memory location,
or an immediate number.

U
MOV AX, BX
MOV AX, 5000H
G
MOV AX, [SI]
MOV AX, [2000H]
MOV AX, 50H [BX]
U
MOV [734AH], BX
MOV DS, CX
AN

MOV CL, [357AH]

Direct loading of the segment registers with immediate data is not permitted.

PUSH: Push to Stack

H

This instruction pushes the contents of the specified register/memory location on to the stack. The stack
pointer is decremented by 2, after each execution of the instruction.
.B

Ex: - PUSH AX
PUSH DS
G

PUSH [5000H]

3
 A
Fig: Push data to Stack memory

PT
POP: Pop from Sack
This instruction when executed, loads the specified register/memory location with the contents of the
memory location of which the address is formed using the current stack segment and stack pointer.
The stack pointer is incremented by 2
Ex: - POP AX
POP DS
U
G
POP [5000H]
U
AN
H
.B

Fig: Poping Register content from stack memory

XCHG: Exchange byte or word

G

This instruction exchanges the contents of the specified source and destination operands
Ex: - XCHG [5000H], AX
XCHG BX, AX

4
XLAT: Translate byte using look-up table
Ex: - MOV BX, OFFSET TABLE

MOV AL, 00H

XLAT
3
5
(AL) ← 5 (BX)
AL [BX+AL]
Base of table
Simple input and output port transfer Instructions:

IN:
Copy a byte or word from specified port to accumulator.

A
Ex: - IN AL,03H
IN AX, DX

PT
OUT:
Copy a byte or word from accumulator specified port.
Ex: - OUT 03H, AL

U
OUT DX, AX
LEA:
G
Load effective address of operand in specified register.
[reg] offset portion of address in DS
Ex: - LEA reg, offset
U

LDS:
AN

Load DS register and other specified register from memory.

[reg] [mem]
[DS] [mem + 2]
Ex: - LDS reg, mem
H

LES:
Load ES register and other specified register from memory.
.B

[reg] [mem]
[ES] [mem + 2]
G

Ex: - LES reg, mem

5
Flag transfer instructions:

LAHF:
Load (copy to) AH with the low byte the flag register.
[AH] [Flags low byte]
Ex: - LAHF

SAHF:
Store (copy) AH register to low byte of flag register.
[Flags low byte] ← [AH]
Ex: - SAHF
PUSHF:

A
Copy flag register to top of stack.
[SP] ← [SP] – 2

PT
[[SP]] ← [Flags]
Ex: - PUSHF
POPF:

U
Copy word at top of stack to flag register.
[Flags] ← [[SP]]
G
[SP] ← [SP] + 2

Ex: - POPF
U

b) Arithmetic Instructions:
The 8086 provides many arithmetic operations: addition, subtraction, negation, multiplication and
AN

comparing two values.

ADD:
The add instruction adds the contents of the source operand to the destination operand.
Ex: - ADD AX, 0100H
H

ADD AX, BX
ADD AX, [SI]
.B

ADD AX, [5000H]

ADD [5000H], 0100H
G

ADD 0100H

6
ADC: Add with Carry
This instruction performs the same operation as ADD instruction, but adds the carry flag to the result.
Ex: - ADC 0100H
ADC AX, BX
ADC AX, [SI]
ADC AX, [5000]
ADC [5000], 0100H

SUB: Subtract
The subtract instruction subtracts the source operand from the destination operand and the result is left in
the destination operand.

A
Ex: - SUB AX, 0100H
SUB AX, BX

PT
SUB AX, [5000H]
SUB [5000H], 0100H
SBB: Subtract with Borrow

U
The subtract with borrow instruction subtracts the source operand and the borrow flag (CF) which may
reflect the result of the previous calculations, from the destination operand
Ex: - SBB AX, 0100H
G
SBB AX, BX
SBB AX, [5000H]
U
SBB [5000H], 0100H
INC: Increment
AN

This instruction increases the contents of the specified Register or memory location by 1. Immediate data
cannot be operand of this instruction.
Ex: - INC AX
INC [BX]
H

INC [5000H]

DEC: Decrement
.B

The decrement instruction subtracts 1 from the contents of the specified register or memory location.
Ex: - DEC AX
G

DEC [5000H]

7
NEG: Negate
The negate instruction forms 2’s complement of the specified destination in the instruction. The
destination can be a register or a memory location. This instruction can be implemented by inverting each
bit and adding 1 to it.
Ex: - NEG AL
AL = 0011 0101 35H Replace number in AL with its 2’s complement
AL = 1100 1011 = CBH
CMP: Compare
This instruction compares the source operand, which may be a register or an immediate data or a memory
location, with a destination operand that may be a register or a memory location
Ex: - CMP BX, 0100H

A
CMP AX, 0100H

PT
CMP [5000H], 0100H
CMP BX, [SI]
CMP BX, CX
MUL: Unsigned Multiplication Byte or Word

U
This instruction multiplies an unsigned byte or word by the contents of AL.
Ex: - MUL BH; (AX) ← (AL) x (BH)
G
MUL CX; (DX) (AX) ← (AX) x (CX)
MUL WORD PTR [SI]; (DX) (AX) ← (AX) x ([SI])
IMUL: Signed Multiplication
U

This instruction multiplies a signed byte in source operand by a signed byte in AL or a signed word in
source operand by a signed word in AX.
AN

Ex: - IMUL BH
IMUL CX
IMUL [SI]
CBW: Convert Signed Byte to Word
H

This instruction copies the sign of a byte in AL to all the bits in AH. AH is then said to be sign extension
of AL.
.B

Ex: - CBW
AX= 0000 0000 1001 1000 Convert signed byte in AL signed word in AX.
G

Result in AX = 1111 1111 1001 1000

CWD: Convert Signed Word to Double Word
This instruction copies the sign of a byte in AL to all the bits in AH. AH is then said to be sign extension
of AL.
8
Ex: - CWD
Convert signed word in AX to signed double word in DX: AX
DX= 1111 1111 1111 1111
Result in AX = 1111 0000 1100 0001
DIV: Unsigned division
This instruction is used to divide an unsigned word by a byte or to divide an unsigned double word by a
word.
Ex: - DIV CL ; Word in AX / byte in CL
; Quotient in AL, remainder in AH
DIV CX ; Double word in DX and AX / word in CX, and Quotient in AX, remainder in DX
AAA: ASCII Adjust After Addition

A
The AAA instruction is executed after an ADD instruction that adds two ASCII coded operand to give a

PT
byte of result in AL. The AAA instruction converts the resulting contents of AL to a unpacked decimal
digits.
AAA operation:
1) In AL If rightmost nibble is >9 (ie) A to F or Auxiliary Flag=1

U
ADD 6 to rightmost nibble
2) Clear left nibble form AL.
G
3) In AH ADD 1
4) Set Carry and Auxiliary Carry
Ex: - ADD CL, DL ; [CL] = 34H = ASCII for 4
U

; [DL] = 38H = ASCII for 8

; Result [CL] = 6CH
AN

AAA ; [AL] =02, unpacked BCD for 2

; [AH] =01, unpacked BCD for 1
AAS: ASCII Adjust AL after Subtraction
This instruction corrects the result in AL register after subtracting two unpacked ASCII operands. The
H

result is in unpacked decimal format. The procedure is similar to AAA instruction except for the
subtraction of 06 from AL.
.B

AAS operation:
1) AAS checks the rightmost nibble in AL If rightmost nibble is >9 (ie) A to F Or
G

Auxiliary Flag=1, Then Subtract 6 from rightmost nibble

2) Clear left nibble in AL.

3) Subtracts 1 from AH

9
 4) Set Carry and Auxiliary Carry
Ex: - MOV AL, 34H
SUB AL, 38H ; AX=00FC
AAS ; AX= FF06 ten’s complement i.e -4 (Borrow one from AH)
OR AL, 30H ; AL=34
AAM: ASCII Adjust after Multiplication
This instruction, after execution, converts the product available In AL into unpacked BCD format.
AAM performs the following operations
1) Divides AL value by 10 (0AH)
2) Stores Quotient in AH
3) Store Remainder in AL

A
Ex: - MOV AL, 04 ; AL = 04

PT
MOV BL, 09 ; BL = 09
MUL BL ; AX = AL*BL ; AX=0024H
AAM ; AH = 03H, AL=06H
AAD: ASCII Adjust before Division

U
This instruction converts two unpacked BCD digits in AH and AL to the equivalent binary number in AL.
This adjustment must be made before dividing the two unpacked BCD digits in AX by an unpacked BCD
G
byte. In the instruction sequence, this instruction appears Before DIV instruction.
Operations done by AAD instruction
1) AAD multiplies the AH by 10(0Ah).
U

2) Then adds the product to AL and clears the AH

Ex: - AX 05 08
AN

AAD result in AL 00 3A 58D = 3A H in AL

The result of AAD execution will give the hexadecimal number 3A in AL and 00 in AH. Where 3A is the
hexadecimal equivalent of 58 (decimal).
DAA: Decimal Adjust Accumulator
H

This instruction is used to convert the result of the addition of two packed BCD numbers to a valid BCD
number. The result has to be only in AL.
.B

Ex: - AL = 53H, CL = 29H

ADD AL, CL ; AL ← (AL) + (CL)
G

; AL ← 53 + 29
; AL ← 7C
DAA ; AL ← 7C + 06 (as C > 9)
; AL 82
10
DAS: Decimal Adjust after Subtraction
This instruction converts the result of the subtraction of two packed BCD numbers to a valid BCD
number. The subtraction has to be in AL only.
Ex: - AL = 75H, BH = 46H
SUB AL, BH ; AL ← 2 FH = (AL) - (BH)
; AF = 1
DAS ; AL ← 29 (as F>9, F - 6 = 9)

Logical Instructions:
AND: Logical AND

A
This instruction bit by bit ANDs the source operand that may be an immediate register or a memory
location to the destination operand that may a register or a memory location. The result is stored in the

PT
destination operand.
Ex: - AND AX, 0008H
AND AX, BX

U
OR: Logical OR
This instruction bit by bit ORs the source operand that may be an immediate, register or a memory
G
location to the destination operand that may a register or a memory location. The result is stored in the
destination operand.
Ex: - OR AX, 0008H
U
OR AX, BX
NOT: Logical Invert
AN

This instruction complements the contents of an operand register or a memory location, bit by bit.
Ex: - NOT AX
NOT [5000H]
XOR: Logical Exclusive OR
H

This instruction bit by bit XORs the source operand that may be an immediate, register or a memory
location to the destination operand that may a register or a memory location. The result is stored in the
.B

destination operand.
Ex: - XOR AX, 0098H
XOR AX, BX
G

TEST: Logical Compare Instruction

The TEST instruction performs a bit by bit logical AND operation on the two operands. The result of this
AND ing operation is not available for further use, but flags are affected.

11
Ex: - TEST AX, BX
TEST [0500], 06H

c) Branch Instructions:
Branch Instructions transfers the flow of execution of the program to a new address specified in the
instruction directly or indirectly. When this type of instruction is executed, the CS and IP registers get
loaded with new values of CS and IP corresponding to the location to be transferred.
The Branch Instructions are classified into two types
i. Unconditional Branch Instructions.
ii. Conditional Branch Instructions.
Unconditional Branch Instructions:

A
In Unconditional control transfer instructions, the execution control is transferred to the specified
location independent of any status or condition. The CS and IP are unconditionally modified to the new

PT
CS and IP.
CALL: Unconditional Call
This instruction is used to call a Subroutine (Procedure) from a main program. Address of procedure may

U
be specified directly or indirectly.
There are two types of procedure depending upon whether it is available in the same segment or in another
segment.
G
i. Near CALL i.e., ±32K displacement.
ii. Far CALL i.e., anywhere outside the segment.
U
On execution this instruction stores the incremented IP & CS onto the stack and loads the CS & IP
registers with segment and offset addresses of the procedure to be called.
AN

RET: Return from the Procedure.

At the end of the procedure, the RET instruction must be executed. When it is executed, the previously
stored content of IP and CS along with Flags are retrieved into the CS, IP and Flag registers from the stack
and execution of the main program continues further.
H

INT N: Interrupt Type N.

In the interrupt structure of 8086, 256 interrupts are defined corresponding to the types from 00H to FFH.
.B

When INT N instruction is executed, the type byte N is multiplied by 4 and the contents of IP and CS of
the interrupt service routine will be taken from memory block in 0000 segment.
INTO: Interrupt on Overflow
G

This instruction is executed, when the overflow flag OF is set. This is equivalent to a Type 4 Interrupt
instruction.

12
JMP: Unconditional Jump
This instruction unconditionally transfers the control of execution to the specified address using an 8-bit or
16-bit displacement. No Flags are affected by this instruction.
IRET: Return from ISR
When it is executed, the values of IP, CS and Flags are retrieved from the stack to continue the execution
of the main program.

d) LOOP Instructions:
LOOP Unconditionally
This instruction executes the part of the program from the Label or address specified in the instruction up

A
to the LOOP instruction CX number of times. At each iteration, CX is decremented automatically and
JUMP IF NOT ZERO structure.

PT
Ex: - MOV CX, 0004H
MOV BX, 7526H
Label 1: MOV AX, CODE
OR BX, AX
LOOP Label 1
Conditional Branch Instructions:
U
G
When this instruction is executed, execution control is transferred to the address specified
relatively in the instruction, provided the condition implicit in the opcode is satisfied. Otherwise execution
continues sequentially.
U

JZ/JE Label
Transfer execution control to address ‘Label’, if ZF=1.
AN

JNZ/JNE Label
Transfer execution control to address ‘Label’, if ZF=0
JS Label
Transfer execution control to address ‘Label’, if SF=1.
H

JNS Label
Transfer execution control to address ‘Label’, if SF=0.
.B

JO Label
Transfer execution control to address ‘Label’, if OF=1.
G

JNO Label
Transfer execution control to address ‘Label’, if OF=0.
JNP Label
Transfer execution control to address ‘Label’, if PF=0.
13
JP Label
Transfer execution control to address ‘Label’, if PF=1.
JB Label
Transfer execution control to address ‘Label’, if CF=1.
JNB Label
Transfer execution control to address ‘Label’, if CF=0.
JCXZ Label
Transfer execution control to address ‘Label’, if CX=0

Conditional LOOP

A
LOOPZ / LOOPE Label
Loop through a sequence of instructions from label while ZF=1 and CX=0.

PT
LOOPNZ / LOOPENE Label
Loop through a sequence of instructions from label while ZF=1 and CX=0.

U
e) Flag Manipulation and Processor Control Instructions:
These instructions control the functioning of the available hardware inside the processor chip. These
G
instructions are categorized into two types:
1. Flag Manipulation instructions.
2. Machine Control instructions.
U

Flag Manipulation instructions:

The Flag manipulation instructions directly modify some of the Flags of 8086.
AN

i. CLC – Clear Carry Flag.

ii. CMC – Complement Carry Flag.
iii. STC – Set Carry Flag.
iv. CLD – Clear Direction Flag.
H

v. STD – Set Direction Flag.

vi. CLI – Clear Interrupt Flag.
.B

vii. STI – Set Interrupt Flag.

G

Machine Control instructions

The Machine control instructions control the bus usage and execution
i. WAIT – Wait for Test input pin to go low.
ii. HLT – Halt the process.
14
 iii. NOP – No operation.
iv. ESC – Escape to external device like NDP
v. LOCK – Bus lock instruction prefix.

f) Shift & Rotate Instructions:

SAL/SHL: SAL / SHL destination, count
SAL and SHL are two mnemonics for the same instruction. This instruction shifts each bit in the specified
destination to the left and 0 is stored at LSB position. The MSB is shifted into the carry flag. The
destination can be a byte or a word.
It can be in a register or in a memory location. The number of shifts is indicated by count.

A
PT
Ex: - SAL CX, 1
SAL AX, CL
SHR: SHR destination, count

U
This instruction shifts each bit in the specified destination to the right and 0 is stored at MSB position. The
G
LSB is shifted into the carry flag. The destination can be a byte or a word.
It can be a register or in a memory location. The number of shifts is indicated by count.
U
AN

Ex: - SHR CX, 1

MOV CL, 05H
SHR AX, CL
H

SAR: SAR destination, count

This instruction shifts each bit in the specified destination some number of bit positions to the right. As a
.B

bit is shifted out of the MSB position, a copy of the old MSB is put in the MSB position. The LSB will be
shifted into CF.
G

15
Ex: - SAR BL, 1
MOV CL, 04H
SAR DX, CL
ROL Instruction: ROL destination, count
This instruction rotates all bits in a specified byte or word to the left some number of bit positions. MSB is
placed as a new LSB and a new CF.

Ex: - ROL CX, 1

A
MOV CL, 03H
ROL BL, CL

PT
ROR Instruction: ROR destination, count
This instruction rotates all bits in a specified byte or word to the right some number of bit positions. LSB
is placed as a new MSB and a new CF.

U
G
Ex: - ROR CX, 1
MOV CL, 03H
U
ROR BL, CL

RCL Instruction: RCL destination, count

AN

This instruction rotates all bits in a specified byte or word some number of bit positions to the left along
with the carry flag. MSB is placed as a new carry and previous carry is place as new LSB.
H
.B

Ex: - RCL CX, 1

G

MOV CL, 04H

RCL AL, CL

16
RCR Instruction: RCR destination, count
This instruction rotates all bits in a specified byte or word some number of bit positions to the right along
with the carry flag. LSB is placed as a new carry and previous carry is place as new MSB.

Ex: - RCR CX, 1

MOV CL, 04H
RCR AL, CL

A
g) String Manipulation Instructions:
A series of data byte or word available in memory at consecutive locations, to be referred as Byte

PT
String or Word String. A String of characters may be located in consecutive memory locations, where
each character may be represented by its ASCII equivalent.
The 8086 supports a set of more powerful instructions for string manipulations for referring to a string,

U
two parameters are required.
I. Starting and End Address of the String.
II. Length of the String.
G
The length of the string is usually stored as count in the CX register. The incrementing or decrementing of
the pointer, in string instructions, depends upon the Direction Flag (DF) Status. If it is a Byte string
U
operation, the index registers are updated by one. On the other hand, if it is a word string operation, the
index registers are updated by two.
AN

REP: Repeat Instruction Prefix

This instruction is used as a prefix to other instructions, the instruction to which the REP prefix is
provided, is executed repeatedly until the CX register becomes zero (at each iteration CX is automatically
H

decremented by one).
i. REPE / REPZ - repeat operation while equal / zero.
.B

ii. REPNE / REPNZ - repeat operation while not equal / not zero.
These are used for CMPS, SCAS instructions only, as instruction prefixes.
G

17
 A
PT
MOVSB / MOVSW: Move String Byte or String Word
Suppose a string of bytes stored in a set of consecutive memory locations is to be moved to another
set of destination locations. The starting byte of source string is located in the memory location whose
address may be computed using SI (Source Index) and DS (Data Segment) contents.

U
The starting address of the destination locations where this string has to be relocated is given by DI
(Destination Index) and ES (Extra Segment) contents.
G
Ex: - Block move program using the move string instruction
MOV AX, DATA SEG ADDR
MOV DS, AX
U

MOV ES, AX
MOV SI, BLK 1 ADDR
AN

MOV DI, BLK 2 ADDR

MOV CK, N
CLD ; DF=0
NEXT: MOV SB
H

LOOP NEXT
HLT
.B

CMPSB/SW: Compare String Byte or String Word

- The CMPS instruction can be used to compare two strings of byte or words. The length of the string
G

must be stored in the register CX. If both the byte or word strings are equal, zero Flag is set.
- The REP instruction Prefix is used to repeat the operation till CX (counter) becomes zero or the
condition specified by the REP Prefix is False.

18
SCANSB/SW: Scan String Byte or String Word
This instruction scans a string of bytes or words for an operand byte or word specified in the
register AL or AX. The String is pointed to by ES: DI register pair. The length of the string s stored in CX.
The DF controls the mode for scanning of the string. Whenever a match to the specified operand is
found in the string, execution stops and the zero Flag is set. If no match is found, the zero flag is reset.
LODSB/SW: Load String Byte or String Word
The LODS instruction loads the AL / AX register by the content of a string pointed to by DS: SI
register pair. The SI is modified automatically depending upon DF, If it is a byte transfer (LODSB), the SI
is modified by one and if it is a word transfer (LODSW), the SI is modified by two. No other Flags are
affected by this instruction.
STOSB/SW: Store String Byte or String Word

A
- The STOS instruction Stores the AL / AX register contents to a location in the string pointer by ES: DI

PT
register pair. The DI is modified accordingly; No Flags are affected by this instruction.
- The direction Flag controls the String instruction execution, the source index SI and Destination Index
DI are modified after each iteration automatically.
- If DF=1, then the execution follows auto-decrement mode, SI and DI are decremented automatically

U
after each iteration.
- If DF=0, then the execution follows auto-increment mode. In this mode, SI and DI are incremented
G
automatically after each iteration.
Ex:- Clearing a block of memory with a STOSB operation.
MOV AX, 0
U

MOV DS, AX
MOV ES, AX
AN

MOV DI, A000

MOV CX, OF
CLD
AGAIN: STOSB
H

LOOPNE AGAIN
NEXT: Clear A000 to A00F to 00H
.B
G

19
Addressing Modes of 8086:
The default segment for the addressing modes using BP and SP is SS. For all other addressing
modes, the default segments are DS or ES.
Addressing mode indicates a way of locating data or operands.
Different addressing modes of 8086:
1. Immediate:
In this addressing mode, immediate data is a part of instruction, and appears in the form of
successive byte or bytes.
Ex: - MOV AX, 0050H
Here 0050H is the immediate data and it is moved to register AX. The immediate data may be 8-bit or 16-

A
bit in size.
2. Direct:

PT
In the direct addressing mode, a 16-bit address (offset) is directly specified in the instruction as a
part of it.
Ex: - MOV AX, [1000H]
Here data resides in a memory location in the data segment, whose effective address is
10H  DS 1000H
3. Register:
U
G
In register addressing mode, the data is stored in a register and it is referred using the particular
register. All the registers except IP may be used in this mode.
Ex: - MOV AX, BX
U

4. Register Indirect:
AN

In this addressing mode, the address of the memory location which contains data or operand is
determined in an indirect way using offset registers. The offset address of data is in either BX or SI or DI
register. The default segment register is either DS or ES.
H

Ex: - MOV AX,  BX 

The data is present in a memory location in DS whose offset is in BX. The effective address is
.B

10H  DS BX 

5. Indexed:
In this addressing mode offset of the operand is stored in one of the index register. DS and ES are
G

the default segments for index registers SI and DI respectively

Ex: - MOV AX,  SI 

The effective address of the data is 10H  DS SI 

20
6. Register Relative: In this addressing mode the data is available at an effective address formed by
adding an 8-bit or 16-bit displacement with the content of any one of the registers BX, BP, SI and DI in
the default either DS or ES segment.

Ex: - MOV AX, 50H BX 

The effective address of the data is 10H  DS  50H BX 

7. Based Indexed:
In this addressing mode the effective address of the data is formed by adding the content of a base
register (any one of BX or BP) to the content of an index register (any one of SI or DI). The default
segment register may be ES or DS.

Ex: - MOV AX,  BX  SI 

A
The effective address is 10H  DS  BX   SI 

PT
8. Relative Based Indexed:
The effective address is formed by adding an 8-bit or 16-bit displacement with the sum of contents
of any one of the base register (BX or BP) and any one of the index registers in a default segment.
Ex: - MOV AX, 50H BX  SI 

U
Here 50H is an immediate displacement. The effective address is10H  DS   BX   SI   50H .
G
9. Intrasegment Direct Mode:
In this mode, the address to which the control is to be transferred lies in the segment in which the
control transfer instruction lies and appears directly in the instruction as an immediate displacement value.
U
The displacement is computed relative to the content of the instruction pointer IP.
10. Intrasegment Indirect Mode:
AN

This mode is similar to intrasegment direct mode except the displacement to which control is to be
transferred is passed to the instruction indirectly. Here the branch address is found as the content of a
register or a memory location.
11. Intersegment Direct Mode:
H

In this mode, the address to which the control is to be transferred is in a different segment. This
addressing mode provides a means of branching from one code segment to another code segment. Here,
.B

the CS and IP of the destination address are specified directly in the instruction.
12. Intersegment Indirect Mode:
This mode is similar to intersegment direct mode except the address to which the control is to be
G

transferred is passed to the instruction indirectly. This information is kept in a memory block of 4 bytes:
IP (LSB), IP(MSB), LS(LSR) and CS(MSB) sequentially. The starting address of the memory block may
be referred using any of the addressing modes, except immediate mode.

21
 Assembler Directives and Operators:
The main advantage of machine language programming is that the memory control is directly in
the hands of the programmer, so that, he may be able to manage the memory of the system more
efficiently. On the other hand, the disadvantages are more prominent. The programming, coding and
resource management techniques are tedious. The programmer has to take care of these functions hence
the chances of human errors are more. The programs are difficult to understand unless one has a thorough
technical knowledge of the processor architecture and instruction set.
The assembly language programming is simpler as compared to the machine language
programming. The instruction mnemonics are directly written in the assembly language programs. The
programs are now more readable to users than the machine language programs. The main improvement in

A
assembly language over machine language is that the address values and the constants can be identified by
labels. If the labels are suggestive, then certainly the program will become more understandable, and each

PT
time the programmer will not have to remember the different constants and the addresses at which they are
stored, throughout the programs. The labels may help to identify the addresses and constants. Due to this
facility, the tedious byte handling and manipulations are got rid of. Similarly, now different logical
segments and routines may be assigned with the labels rather than the different addresses. The memory

U
control feature of machine language programming is left unchanged by providing storage define facilities
in assembly language programming. The documentation facility which was not possible with machine
G
language programming is now available in assembly language.
An assembler is a program used to convert an assembly language program into the equivalent
machine code modules which may further be converted to executable codes. The assembler decides the
U

address of each label and substitutes the values for each of the constants and variables. It then forms the
machine code for the mnemonics and data in the assembly language program. While doing these things,
AN

the assembler may find out syntax errors. The logical errors or other programming errors are not found out
by the assembler. For completing all these tasks, an assembler needs some hints from the programmer, i.e.
the required storage for a particular constant or variable, logical names of the segments, types of the
H

different routines and modules, end of file, etc. These, types of hints are given to the assembler using
some predefined alphabetical strings called assembler directives. Assembler directives help the assembler
.B

to correctly understand the assembly language programs to prepare the codes.

Another type of hint which helps the assembler to assign a particular constant with a label or
initialize particular memory locations or labels with constants is called an operator . Rather, the operators
G

perform the arithmetic and logical tasks unlike directives that just direct the assembler to correctly
interpret the program to code it appropriately. The following directives are commonly used in the
assembly language programming practice using Microsoft Macro Assembler (MASM) or Turbo
Assembler (TASM).
22
DIRECTIVES:
DB: Define Byte
The DB directive is used to reserve byte or bytes of memory locations in the available memory.
Example:
LIST DB 0lH, 02H, 03H, 04H

This statement directs the assembler to reserve four memory locations for a list named LIST and initialize
them with the above specified four values.

MESSAGE DB 'GOOD MORNING'

This makes the assembler reserve the number of bytes of memory equal to the number of characters in the
string named MESSAGE and initialize those locations by the ASCII equivalent of these characters.

A
VALUE DB 50H

PT
This statement directs the assembler to reserve 50H memory bytes and leave them uninitialized for the
variable named VALUE.

DW: Define Word.

U
The DW directive serves the same purposes as the DB directive, but it now makes the assembler
reserve the number of memory words (16-bit) instead of bytes.
G
Example:
WORDS DW 1234H, 4567H, 78ABH, 045CH
This makes the assembler reserve four words in memory (8 bytes), and initialize the words with the
U
specified values in the statements.
Another option of the DW directive is explained with the DUP operator.
AN

WDATA DW 5 DUP (6666H)

This statement reserves five words, i.e. 10-bytes of memory for a word label WDATA and initializes all
the word locations with 6666H.
H

DQ: Define Quad word

This directive is used to direct the assembler to reserve 4 words (8 bytes) of memory for the
.B

specified variable and may initialize it with the specified values.

G

DT: Define Ten Bytes.

The DT directive directs the assembler to define the specified variable requiring 10-bytes for its
storage and initialize the 10 bytes with the specified values. The directive may be used in case of variables
facing heavy numerical calculations, generally processed by numerical processors.
23
ASSUME: Assume Logical Segment Name
The ASSUME directive is used to inform the assembler, the names of the logical segments to be assumed
for different segments used in the program.
ASSUME CS: CODE, DS: DATA, SS: STACK
END: END of Program
The END directive marks the end of an assembly language program.

ENDS: END of Segment

This directive marks the end of a logical segment. The logical segments are assigned with the names using
the ASSUME directive.
DATA SEGMENT

A
.

PT
.
DATA ENDS
ASSUME CS: CODE, DS: DATA
CODE SEGMENT.

U
.
.
G
CODE ENDS
END
U
ENDP: END of Procedure.
In assembly language programming, the subroutines are called procedures. The ENDP directive is
AN

used to indicate the end of a procedure.

Ex: - PROCEDURE STAR
.
.
H

.
STAR ENDP
.B

EVEN: Align on Even Memory Address

The EVEN directive updates the location counter to the next even address if the current location
G

counter contents are not even, and assigns the following routine or variable or constant to that address.

24
Ex: - EVEN
PROCEDURE ROOT
.
.
.
ROOT ENDP

EQU: Equate
The directive EQU is used to assign a label with a value or a symbol. The use of this directive is
just to reduce the recurrence of the numerical values or constants in a program code.
Ex: -

A
LABEL EQU 0500H
ADDITION EQU ADD

PT
EXTRN: External and PUBLIC: Public
The directive EXTRN informs the assembler that the names, procedures and labels declared after
this directive have already been defined in some other assembly language modules. While in the other

U
module, where the names, procedures and labels actually appear, they must be declared public, using the
PUBLIC directive.
G
If one wants to call a procedure FACTORIAL appearing in MODULE 1 from MODULE 2; in
MODULE1, it must be declared PUBLIC using the statement PUBLIC FACTORIAL and in module 2, it
must be declared external using the declaration EXTRN FACTORIAL. The statement of declaration
U

EXTRN must be accompanied by the SEGMENT and ENDS directives of the MODULE 1, before it is
called in MOBULE 2. Thus, the MODULE 1 and MODULE 2 must have the following declarations.
AN

Ex: - MODULEl SEGMENT

PUBLIC FACTORIAL FAR

H

MODULEl ENDS
.B

MODULE2 SEGMENT
G

EXTRN FACTORIAL FAR

MODULE2 ENDS

25
GROUP: Group the Related segment
The directive is used to form logical groups of segments with similar purpose or type. This
directive is used to inform the assembler to form a logical group of the following segment names.
Ex: - PROGRAM GROUP CODE, DATA, STACK

ASSUME CS: PROGRAM, DS: PROGRAM, SS: PROGRAM.

LABEL: Label
The Label directive is used to assign a name to the current content of the location counter.
A LABEL directive may be used to make a FAR jump as shown below.
A FAR jump cannot be made at a normal label with a colon.

A
LENGTH: Byte Length of a Label
This directive is not available in TASM. This is used to refer to the length of a data array or a string.

PT
Ex: - MOV CX, LENGTH ARRAY
This statement, when assembled, will substitute the length of the array ARRAY in bytes, in the
instruction.

ORG: Origin

U
G
The ORG directive directs the assembler to start the memory allotment for the particular segment,
block or code from the declared address in the ORG statement while starting the assembly process for a
module, the assembler initializes a location counter to keep track of the allotted addresses for the module.
U
If the ORG statement is not written in the program, the location counter is initialized to 0000.
AN

PROC: Procedure
The PROC directive marks the start of a named procedure in the statement. Also, the types NEAR
or FAR specify the type of the procedure, i.e whether it is to be called by the main program located within
64K of physical memory or not.
H

Ex: - RESULT PROC NEAR

ROUTINE PROC FAR

.B

SEGMENT: Logical Segment

The SEGMENT directive marks the starting of a logical segment. The started segment is also
G

assigned a name, i.e. label, by this statement.

26
OPERATORS:
OFFSET: Offset of a Label
When the assembler comes across the OFFSET operator along with a label, it first computes the
16-bit displacement (also called as offset interchangeably) of the particular label, and replaces the string
'OFFSET LABEL' by the computed displacement. This operator is used with arrays, strings, lables and
procedures to decide their offsets in their default segments.
Ex: - DATA SEGMENT
LIST DB 10H
DATA ENDS
CODE SEGMENT

A
MOV SI, OFFSET LIST
CODE ENDS

PT
PTR: Pointer
The pointer operator is used to declare the type of a label, variable or memory operand. The
operator PTR is prefixed by either BYTE or WORD.
 If the prefix is BYTE, then the particular label, variable or memory operand is treated as an 8-bit

Ex: - MOV AL, BYTE PTR [SI]

U
quantity, while if WORD is the prefix, then it is treated as a 16- bit quantity.
; Moves content of memory location addressed by SI (8-bit) to AL
G
INC BYTE PTR [BX] ; Increments byte contents of memory location addressed by BX
MOV BX, WORD PTR [2000H] ; Moves 16-bit content of memory location 2000H to BX, i.e.
[2000H] to BL [2001 H] to BH
U

INC WORD PTR [3000H] ; Increments word contents of memory location 3000H
Considering contents of 3000H (lower byte) and 3001
AN

H(higher byte) as a 16-bit number

SEG: Segment of a Label
The SEG operator is used to decide the segment address of the label, variable, or procedure and
substitutes the segment base address in place of ‘SEG label’.
H

Ex: - MOV AX, SEG ARRAY ; This statement moves the segment address
MOV DS, AX ; of ARRAY in which it is appearing, to register AX and then to DS.
.B

SHORT
G

The SHORT operator indicates to the assembler that only one byte is required to code the
displacement for a jump (i.e. displacement is within -128 to +127 bytes from the address of the byte next
to the jump opcode).
Ex: - JMP SHORT LABEL
27
 Simple Assembly Language Programs 8086
The assembly language programming 8086 has some rules such as
 The assembly level programming 8086 code must be written in upper case letters
 The labels must be followed by a colon, for example: label:
 All labels and symbols must begin with a letter
 All comments are typed in lower case
 The last line of the program must be ended with the END directive
8086 processors have two other instructions to access the data, such as WORD PTR – for
word (two bytes), BYTE PTR – for byte.

Op-code: A single instruction is called as an op-code that can be executed by the CPU. Here
the ‘MOV’ instruction is called as an op-code.
Operands: A single piece data are called operands that can be operated by the op-code.
Example, subtraction operation is performed by the operands that are subtracted by the
operand.
Syntax: SUB b, c

8086 microprocessor assembly language programs

Write a Program for Read a Character from The Keyboard

MOV ah, 1h //keyboard input subprogram

INT 21h // character input
// character is stored in al
MOV c, al //copy character from alto c

Write a Program for Reading and Displaying a Character

MOV ah, 1h // keyboard input subprogram

INT 21h //read character into al
MOV dl, al //copy character to dl
MOV ah, 2h //character output subprogram
INT 21h // display character in dl

Write a Program Using General Purpose Registers

ORG 100h
MOV AL, VAR1 // check value of VAR1 by moving it to the AL.
LEA BX, VAR1 //get address of VAR1 in BX.
MOV BYTE PTR [BX], 44h // modify the contents of VAR1.
MOV AL, VAR1 //check value of VAR1 by moving it to the AL.
RET
VAR1 DB 22h
END
Write a Program for Displaying The String Using Library Functions

include emu8086.inc //Macro declaration

ORG 100h
PRINT ‘Hello World!’
GOTOXY 10, 5
PUTC 65 // 65 – is an ASCII code for ‘A’
PUTC ‘B’
RET //return to the operating system.
END //directive to stop the compiler.

Arithmetic and Logic Instructions

The 8086 processes of arithmetic and logic unit has separated into three groups such as
addition, division, and increment operation. Most Arithmetic and Logic Instructions affect the
processor status register.
The assembly language programming 8086 mnemonics are in the form of op-code, such as
MOV, MUL, JMP, and so on, which are used to perform the operations. Assembly language
programming 8086 examples

Addition
ORG0000h
MOV DX, #07H // move the value 7 to the register AX//
MOV AX, #09H // move the value 9 to accumulator AX//
Add AX, 00H // add CX value with R0 value and stores the result in AX//
END

Multiplication
ORG0000h
MOV DX, #04H // move the value 4 to the register DX//
MOV AX, #08H // move the value 8 to accumulator AX//
MUL AX, 06H // Multiplied result is stored in the Accumulator AX //
END

Subtraction
ORG 0000h
MOV DX, #02H // move the value 2 to register DX//
MOV AX, #08H // move the value 8 to accumulator AX//
SUBB AX, 09H // Result value is stored in the Accumulator A X//
END

Division
ORG 0000h
MOV DX, #08H // move the value 3 to register DX//
MOV AX, #19H // move the value 5 to accumulator AX//
DIV AX, 08H // final value is stored in the Accumulator AX //
END
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
G
.B
H
AN
U
G
U
PT
A
Assembly Language Program Development Tools:

1. Editor
- An editor is a program which allows you to create a file containing the assembly
language statements for your program.
Example: PC-Write, Wordstar.
- As you type in your program, the editor stores the ASCII codes for the letters and
numbers in successive RAM locations.
- When you have typed in your entire program, you then save the file on the hard disk.
This file is called source file and the extension is .asm.

A
2. Assembler
 An assembler program is used to translate the assembly language mnemonics for

PT
instructions to corresponding binary codes. When you run the assembler, it reads the
source file of your program from the disk where you have saved it after editing.
 On the first pass through the source program, the assembler determines the displacement

U
of named data items, the offset of labels, etc. and puts this information in a symbol table.
 On the second pass through the source program, the assembler produces the binary code
G
for each instruction and inserts the offsets, etc. that it calculated during the first pass.
- The assembler generates 2 files on the floppy disk or hard disk. The first file is called
object file (.obj).
U
- The second file generated by assembler is called the assembler list file and is given
extension (.lst).
AN

3. Linker
- A linker is a program used to join several object files into one large object file.
- The linker produces a link file which contains the binary codes for all the combined
H

modules.
- The linker also produces a link map file which contains the address information about the
.B

linked files (.exe).

4. Locator
G

 A locator is a program used to assign the specific address of where the segments of object
code are to be loaded into memory.
 A locator program called EXE2BIN comes with the IBM PC Disk Operating System
(DOS). EXE2BIN converts a` .exe file to a .bin file which has physical addresses.
5. Debugger
- A debugger is a program which allows you to load your object code program into system
memory, execute the program and troubleshoot or debug it.
- The debugger allows you to look at the contents of registers and memory locations after
your program runs.
- It allows you to change the contents of registers and memory locations and re-run the
program.
- Some debuggers allow you to stop execution after each instruction so that you can check
or alter after each register contents.
- A debugger also allows you to set a breakpoint at any point in your program. If you insert
a breakpoint at any point in your program, the debugger will run the program up to the

A
instruction where you put the breakpoint and then stop the execution.

PT
6. Emulator
- An emulator is a mixture of hardware and software.
- It is used to test and debug the hardware and software of an external system, such as the

U
prototype of a microprocessor based instrument. Part of the hardware of an emulator is a
multi wire cable which connects the host system to the system being developed.
G
U
AN
H
.B
G