Assembly Language Programming II

Instruction set

In order to write an assembly language program for a microprocessor, you must

understand the instructions supported by the device. Different microprocessors may
support different operations, however, the basic concept of assembly language
programming is very similar. Moreover, the syntax for the instruction is more or less the
same. Therefore, once you learn assembly language programming for one
microprocessor, then you can easily write programs for other microprocessors.
For example, the move operation (syntax MOV) can be found in the Intel
microprocessors, and the ADuC832 microcontroller. In PowerPC, there is the lwz, which
stands for the load operation. Other processors may use the load instruction.

The 8086 instruction set is relatively simple and it has a total of 117 basic instructions. If
you understand all basic instructions then you can fully control the 8086. Moreover, since
Intel processors are upward compatible so your assembly language program can run on
all Intel processor including the P5 or Core2 Duo!!!!

The instructions are divided into 5 groups:

Data transfer – move
Arithmetic – addition, subtraction, multiply, divide
Logic – AND, OR, XOR
Shift
Rotate

We will go through the different groups one by one, however, for details descriptions, you
should refer to the document provided by the emu8086 software or a proper reference.

Data transfer instructions

The main purpose of the data transfer instructions is to move data either between its
internal registers or between an internal register and a storage location in memory. The
most frequently used data transfer instruction is the move operation, mnemonic MOV.

Syntax: MOV destination, source ; move data from source to destination

The data being moved could be 16-bit or 8-bit

The system does not support moving data from one memory location to another memory
location. When the segment register is used in a data transfer operation then the move
instruction must be applied to a 16-bit data.

For example, Mov SS, data

where SS represents a segment register, such as DS, ES, then data must be a 16-bit value.
Mnemonic Meaning Format Operation Flags affected
Mov Move mov D,S (S) to (D) none

Destination (D) Source (S)

Memory AX
AX Memory
Register Register
Register Memory
Memory Register
Register Immediate
Memory Immediate
Seg-reg Reg16
Seg-reg Mem16
Reg16 Seg-reg

Mem16 Seg-reg

The above table shows the syntax for the MOV instruction and the possible combinations
for the source and destination.

Example:
MOV AL, BL ; register to register
MOV AL, #16 ; immediate (a value 16) to register

Special data transfer instructions

Exchange data between the source and destination – XCHG

Syntax : XCHG AX, DX ; value in DX is stored in AX and value in AX stored
in DX

Load effective address (LEA) is a frequently used instruction for saving the offset
address of a variable. This is similar to x = &y in C++ programming!

Syntax: LEA SI, INPUT ; effective address of INPUT will be stored in SI register
INPUT in the above example represents a variable
Since an offset address is stored so the destination must be a 16-bit register! An offset
address is a 16-bit value!!!
LEA usually is used to access data defined in the program, as shown below.

Example

LEA BX, dat

MOV AL, [BX+2]

What is inside AL if dat is defined as the following?

dat DB 11h, 22h, 33h, 44h, 55h

Load register and DS (LDS)

As its name implies, LDS will load a specified register and the DS register in a single
operation!

Syntax: LDS SI, [200] ; 4 bytes of data will be fetched, the first 2 bytes (location
200 and 201) stored in SI and the following 2 bytes (locations 202 and 203) stored in
DS.

There is also the load register and ES (LES). Similar to LDS, LES will load a specific
register and the ES register.

Arithmetic instructions

Table 1 depicts arithmetic instructions available in the 8086.

Some examples of available arithmetic operations: add, subtract, multiply, etc.
The operations can apply to unsigned value, signed value, binary bytes, words, unpacked,
packed decimal bytes, or even ASCII numbers.

Packed decimal – two BCD digits are packed into a byte register or memory location.
Each BCD is 4 bits representing digit 0 to 9.
Unpacked decimal numbers are stored one BCD digit per byte
After an arithmetic operation, the flags (such as Carry, Sign, Overflow, Zero) are updated
accordingly. Based on the flag status, different operations can be performed, similar to an
IF ELSE syntax.

Table 1 Arithmetic operation of 8086

ADD Add byte or word

ADC Add byte or word with carry
Inc Increment byte or word by 1
AAA ASCII adjust for addition
DAA Decimal adjust for addition
Sub Subtract byte or word
Sbb Subtract byte or word with borrow
DEC Decrement byte or word by 1
NEG Negate byte or word
AAS ASCII adjust for subtraction
DAS Decimal adjust for subtraction
MUL Multiply byte or word unsigned
IMUL Integer multiply byte or word
AAM ASCII adjust for multiply
Div Divide byte or word unsigned
Idiv Integer divide byte or word
AAD ASCII adjust for division
CBW Convert byte to word
CWD Convert word to doubleword

Addition related operations

Mnemonic Meaning Format Operation Flags affected

Add Addition Add D, S D = S+D OF, SF, ZF, AF, PF, CF
CF = carry

ADC Add with carry ADC D, S D = S+D+CF OF, SF, ZF, AF, PF, CF
CF = carry

INC Increment by 1 INC D D = D+1 OF, SF, ZF, AF, PF

AAA ASCII adjust for AAA AF, CF, OF, SF, ZF, PF
addition undefined

DAA Decimal adjust for DAA SF, ZF, AF, PF, CF, OF
addition undefined

Destination Source
Register Register
Register Memory
Memory Register
Register Immediate
Memory Immediate
AX Immediate

Example
AL = 12H, BL = 70H
Carry = 1
ADC AL, BL
Then result is in AL = 83H
The carry is only 1-bit and it is being added to the LSB (least significant bit).

Example
BX = 1234 CX= 0123
Carry is 0
SBB BX, CX ; subtract with borrow
Give 1111

Subtraction

Mnemonic Meaning Format Operation Flags affected

Sub Subtract Sub D,S D = D-S OF, SF, ZF, AF,
CF = borrow PF, CF
Sbb Subtract with SBB D,S D = D-S-CF OF, SF, ZF, AF,
borrow PF, CF
Dec Decrement by 1 DEC D D=D-1 OF, SF, ZF, AF, PF

Neg Negate Neg D D=0-D OF, SF, ZF, AF,

CF =1 PF, CF
DAS Decimal adjust DAS OF, SF, ZF, AF,
for subtraction PF, CF undefined

AAS ASCII adjust for AAS OF, SF, ZF, AF,

subtraction PF, CF undefined

Destination Source

Register Register

Register Memory

Memory Register

AX Immediate

Register Immediate

Memory immediate

If BX = 3A
NEG BX
Give FFC6

NEG – make the operand negative (based on 2’s complement)

Executing the NEG instruction causes the following
2’s complement subtraction
00 - (BX) = 0000 + 2’s complement of 3A
= 0000 + FFC6
 = FFC6

Multiplication

When multiplying 8-bit data, result is 16-bit and stored in AX (a 16-bit register).
When multiplying two 16-bit data, result is 32-bit and result stored in AX and DX.
The AX holds the LSW (Least significant word) and DX stores the MSW (Most
significant word). Only the source operand is specified in the multiply operation and
the other operand must be stored in AL, or AX. This also applies in the division
operation.
In 8-bit division, the result is stored in AH and AL. Where AH is the remainder and AL is
the quotient.
For 16-bit division, AX contains the quotient and DX contains the remainder

If AL is –1 and CL is –2, what will be the result produced in AX for

MUL CL ; this is CL * AL (unsigned)

IMUL CL ; this is CL*AL (signed)

MUL CL is unsigned multiply = FD02 (-1 = FFH; -2 = FEH so FFxFE = FD02H)

IMUL CL is signed multiply = 2 (-1*-2 = 2)

Special functions

CBW – convert byte (8-bit) to word (16-bit). So what is the additional 8 bits?
CBW – fill AH with 0 if AL is positive; fill AH with 1s if AL is negative then AH
becomes FF. In doing so, the sign of the original data will be retained.
CWD – convert word (16-bit) to double word (32-bit) and the DX register is used to store
the high order word.
CWD – fill DX with 0 if AL is positive; fill DX with 1s if AX is negative then DX
becomes FF
Both CBW and CWD do not require operand, the data must be stored in AL or AX.

Use CBW when doing 8-bit operation, AX is used by default.

Use CWD when doing 16-bit operation, AX and DX are used by default.

What is the result of executing the following sequence of instructions?

MOV AL, A1H

CBW
CWD

Ans.
AX = FFA1 after CBW ; AL 8-bit converts to 16-bit AX
DX = FFFF after CWD ; AX is 16-bit converts to 32-bit (DX + AX)
Multiplication and division functions

Mnemonic Meaning Format Operation Flags affected

MUL Multiply MUL S AX = AL*S8 OF, CF depends on
(Unsigned) DX,AX = AX*S16 result

S, Z, A, P undefined
DIV Division DIV S AL = Q (AX/S8)
(unsigned) AH = R(AX/S8) OF, CF, SF, ZF, AF, PF
all undefined
IMUL Integer IMUL S AX = AL*S8 OF, CF depends on
multiply DX,AX=AX*S16 result
(signed) S, Z, A, P undefined
IDIV Integer divide IDIV S AX = Q(AX/S8) OF, CF, SF, ZF, AF, PF
(signed) AH=R(AX/S8) all undefined
AX = Q(DX,AX)/S16
DX=R(DX,AX)/S16
If Q is positive and
exceeds 7FFF or if Q
is negative and
becomes less than
8001 then type 0
interrupt occurs

Multiplication related functions

Mnemonic Meaning Format Operation Flags affected

AAM Adjust AL for AAM AH=Q(AL/10) SF, ZF, PF, OF,
multiplication AL=R(AL/10) AF, CF
Ascii adjust after undefined
Multiplication for
BCD values
AAD Adjust AX for AAD AL=(AH*10+AL) SF, ZF, PF, OF,
division AH =00 AF, CF
Prepare 2 BCD undefined
values for division
CBW Convert byte to CBW All bits of AH = None
word (MSB of AL)

CWD Convert word to CWD All bits of DX = none

double word MSB of AX

A simple application of assembly language programming

Try to write a simple assembly language program to convert from Centigrade (Celsius) to
Fahrenheit assuming result is an integer.
• The equation for the conversion is
• f = c * 9 / 5 + 32
• What operations are required?
• Do you need to define variables?
• Sample is available in the ftp site

Logic instructions

Logic operations include: AND, OR, exclusive­OR (XOR) and NOT

Eg  AND  AX, BX

The above is applying logical AND to value in AX and value in BX. Result is stored in 
AX. The bits in AX and BX are logical ANDed bit­by­bit.

Example:
MOV  AL, 10101100B
AND  AL, 11110000B ; bit by bit operation

AL 1 0 1 0 1 1 0 0
1 1 1 1 0 0 0 0
AND 1 0 1 0 0 0 0 0
  

Describe the result of executing the following:

MOV AL, 01010101B
AND AL, 00011111B (AL = 00010101B)
OR AL, 11000000B (AL = 11010101B)
XOR AL, 00001111B (AL = 11011010B)
NOT AL (AL = 00100101B)

Ans. AL = 00100101

Shift instructions

As its name implies, shift instructions are for shifting the bit(s) out of the operand. So
what will happen to the bit shifted out? What will happen to the vacated bit position?
There are 4 shift operations
Can perform: logical shift and arithmetic shift
Can shift left as well as right
Logical shift – the vacated bit will be filled with ‘0’ and the bit shifted out will be stored
in the Carry flag.
Arithmetic shift – the vacated bit will be filled with the original most significant bit (this
only applies in right shift, in left shift vacated bit is filled with ‘0’ as well.)

Arithmetic shift will maintain the ‘sign’ of the original data

If shift more than 1 bit out then the number of shift operation to be performed is stored in
the CL register.
Shift operations are important because for a binary pattern, shifting 1-bit to the left is
equivalent to multiply the value by 2. For example, if the original value is 1, shifting 1
bit to the left, the value becomes 2!!!!

Original 0 0 0 0 0 0 0 1
Shifted 0 0 0 0 0 0 1 0
1 bit
left

On the other hand, shift to the right is the same as divide the value by 2. For
example, if the original value is 2 then shift to the right by 1 bit, the value becomes 1.
Shift operations can be used in multiply and divide operations.

Mnemonic Meaning Format Operation Flags affected

SAL/SHL Shift arithmetic  SAL/SHL D,  Shift the (D) left by the C,  O depends on 
left/shift logical left Count number of bit positions result
equal to count and fill 
the vacated bits  OF = 0 if first 
positions on the right  operand keeps 
with zeros original sign
SHR Shift logical right SHR D, Count Shift the (D) right by  C,  O depends on 
the number of bit  result
positions equal to 
count and fill the  OF = 0 if first 
vacated bits positions  operand keeps 
on the left with zeros original sign
SAR Shift arithmetic right SAR D, Count Shift the (D) right by  C,  O depends on 
the number of bit  result
positions equal to 
count and fill the  OF = 0 if first 
vacated bits positions  operand keeps 
on the left with the  original sign
original most 
significant bit
 Shift left

Bits being shifted

Shift Right

Example
Mov AL, 10001100b
MOV CL, #1
SHR AL, CL ; shift right 1 time

Result = 0100 0110 Carry = 0

Mov AL, 10001100b

Mov CL, #1
SAL AL, CL ; arithmetic shift right 1 time

Result 1100 0110b Carry = 0

The CL register holds the number of shift to be performed.

Rotate instructions

Rotate is similar to shift but the vacate bit is filled with the bit rotated out from the other
side.
Rotate left through carry (RCL) – bit rotated out is stored in the carry flag, the vacated bit
is filled by the carry flag

Eg RCR BX, CL ; rotate right thro’ carry 4 times

If CL = 04H and BX = 1234H what is the result of the above operation?

The value of CL in the above example represents the number of the rotate operations.
So the rotate 4 times
1000 0001 0010 0011 if C is 0 at the beginning
 Rotate left

Carry

Rotate left thro’ carry

OF=0 if first operand keeps original sign.

Rotate operations

Mnemonic Meaning Format Operation Flags affected

ROL Rotate left ROL D, Count Rotate the D left by the C,  O depends 
number of bit positions on result
equal to Count. Each bit
shifted out from the OF = 0 if first 
leftmost bit goes back operand keeps 
into the rightmost bit original sign
position
ROR Rotate ROR D, Count Rotate the D right by C,  O depends 
Right the number of bit on result
positions equal to
Count. Each bit shifted OF = 0 if first 
out from the rightmost operand keeps 
bit goes back into the original sign
leftmost bit position

RCL Rotate left RCL D, Count Same as ROL except C,  O depends 

thro’ carry carry is attached to D on result
for rotation OF = 0 if first 
operand keeps 
original sign
RCR Rotate right RCR D, Count Same as ROL except C,  O depends 
thro’ carry carry is attached to D on result
for rotation
OF = 0 if first 
operand keeps 
original sign

Exercise

1. How would the decimal number 1234 be coded in ASCII and stored in memory
starting at address 0C000H? Assume that least significant digit is stored at the lower
addressed memory location
Ans. 1 = (31H in 0C003H) 2 = (32H in 0C002H) 3 = (33H in 0C001H) 4 = (34H in
0C000H)

2. If register BX contains the value 0100H, register DI contains 0010 and register
DS contains 1075, what physical memory location is swapped when the following
instruction is executed
XCHG [BX+DI], AX
PA = 10750+0100+0010 = 10860H

3. Compute the physical address for the specified operand in each of the following
instructions:
MOV [DI], AX (destination operand) (0B000+0200 = 0B200)
MOV DI, [SI] (source operand) (0B000+0100 = 0B100)
MOV DI+XYZ, AH (destination operand) (0B000+0200+0400 = 0B600)
Given CS=0A00, DS=0B00, SI=0100, DI=0200, BX=0300, XYZ=0400