Assembly Language Programming II instruction set

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.

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.

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.

where SS represents a segment register, such as DS, ES, then data must be a 16-bit value.

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

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.

MOV AL, [BX+2]

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

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

If BX = 3A

Give FFC6

Executing the NEG instruction causes the following

2’s complement subtraction

00 - (BX) = 0000 + 2’s complement of 3A

= 0000 + FFC6

= FFC6

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

IMUL CL ; this is CL*AL (signed)

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

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.

CBW

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 (Unsigned)	MUL S	AX = AL*S8 DX,AX = AX*S16	OF, CF depends on result S, Z, A, P undefined
DIV	Division (unsigned)	DIV S	AL = Q (AX/S8) AH = R(AX/S8)	OF, CF, SF, ZF, AF, PF all undefined
IMUL	Integer multiply (signed)	IMUL S	AX = AL*S8 DX,AX=AX*S16	OF, CF depends on result S, Z, A, P undefined
IDIV	Integer divide (signed)	IDIV S	AX = Q(AX/S8) AH=R(AX/S8) 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	OF, CF, SF, ZF, AF, PF all undefined

Multiplication related functions

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

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
  

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.

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

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.)

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 1 bit left	0	0	0	0	0	0	1	0

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.

Rotate left through carry (RCL) – bit rotated out is stored in the carry flag, the vacated bit is filled by the carry flag

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

OF=0 if first operand keeps original sign.

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
   

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)