Computer Organization

& Assembly Language

- EE2003
Lecture 16
Week 10
Chapter Overview
▸ Shift and Rotate Instructions
▸ Shift and Rotate Applications
▸ Multiplication and Division Instructions
▸ Extended Addition and Subtraction
▸ ASCII and Unpacked Decimal Arithmetic
▸ Packed Decimal Arithmetic

3
Shift and Rotate Instructions
▸ Logical vs Arithmetic Shifts
▸ SHL Instruction
▸ SHR Instruction
▸ SAL and SAR Instructions
▸ ROL Instruction
▸ ROR Instruction
▸ RCL and RCR Instructions
▸ SHLD/SHRD Instructions
4
Logical Shift
▸ A logical shift fills the newly created bit position with zero:

5
Arithmetic Shift
• An arithmetic shift fills the newly created bit position
with a copy of the number’s sign bit:

6
SHL Instruction
▸ The SHL (shift left) instruction performs a logical left shift on the
destination operand, filling the lowest bit with 0.

• Operand types for SHL:

SHL reg,imm8
SHL mem,imm8
SHL reg,CL (Same for all shift and
SHL mem,CL rotate instructions)

7
Fast Multiplication
Shifting left 1 bit multiplies a number by 2

mov dl,5
shl dl,1

Shifting left n bits multiplies the operand by 2n

For example, 5 * 22 = 20
mov dl,5
shl dl,2 ; DL = 20

8
SHR Instruction
▸ The SHR (shift right) instruction performs a logical right shift on the
destination operand. The highest bit position is filled with a zero.

Shifting right n bits divides the operand by 2n

mov dl,80
shr dl,1 ; DL = 40
shr dl,2 ; DL = 10
9
SAL and SAR Instructions
▸ SAL (shift arithmetic left) is identical to SHL.
▸ SAR (shift arithmetic right) performs a right arithmetic shift on the
destination operand.

An arithmetic shift preserves the number's sign.

mov dl,-80
sar dl,1 ; DL = -40
sar dl,2 ; DL = -10 10
Your turn . . .
Indicate the hexadecimal value of AL after each shift:

mov al,6Bh
shr al,1 a. 35h
shl al,3 b. A8h
mov al,8Ch
sar al,1 c. C6h
sar al,3 d. F8h

11
ROL Instruction
▸ ROL (rotate) shifts each bit to the left
▸ The highest bit is copied into both the Carry flag and into the lowest bit
▸ No bits are lost

mov al,11110000b
rol al,1 ; AL = 11100001b

mov dl,3Fh
rol dl,4 ; DL = F3h

12
ROR Instruction
▸ ROR (rotate right) shifts each bit to the right
▸ The lowest bit is copied into both the Carry flag and into the highest bit
▸ No bits are lost

mov al,11110000b
ror al,1 ; AL = 01111000b

mov dl,3Fh
ror dl,4 ; DL = F3h
13
Your turn . . .
Indicate the hexadecimal value of AL after each rotation:

mov al,6Bh
ror al,1 a. B5h
rol al,3 b. ADh

14
RCL Instruction
▸ RCL (rotate carry left) shifts each bit to the left
▸ Copies the Carry flag to the least significant bit
▸ Copies the most significant bit to the Carry flag

clc ; CF = 0
mov bl,88h ; CF,BL = 0 10001000b
rcl bl,1 ; CF,BL = 1 00010000b
rcl bl,1 ; CF,BL = 0 00100001b
15
RCR Instruction
▸ RCR (rotate carry right) shifts each bit to the right
▸ Copies the Carry flag to the most significant bit
▸ Copies the least significant bit to the Carry flag

stc ; CF = 1
mov ah,10h ; CF,AH = 1 00010000b
rcr ah,1 ; CF,AH = 0 10001000b
16
Your turn . . .
Indicate the hexadecimal value of AL after each rotation:

stc
mov al,6Bh
rcr al,1 a. B5h
rcl al,3 b. AEh

17
SHLD Instruction
▸ Shifts a destination operand a given number of bits to the left
▸ The bit positions opened up by the shift are filled by the most
significant bits of the source operand
▸ The source operand is not affected
▸ Syntax:
SHLD destination, source, count
▸ Operand types:

SHLD reg16/32, reg16/32, imm8/CL

SHLD mem16/32, reg16/32, imm8/CL
18
SHLD Example
Shift count of 1:
mov al,11100000b
mov bl,10011101b
shld al,bl,1

19
Another SHLD Example
Shift wval 4 bits to the left and replace its lowest 4 bits with
the high 4 bits of AX:

.data
wval WORD 9BA6h
Before:
.code
mov ax,0AC36h After:
shld wval,ax,4

20
SHRD Instruction
▸ Shifts a destination operand a given number of bits to the right
▸ The bit positions opened up by the shift are filled by the least
significant bits of the source operand
▸ The source operand is not affected
▸ Syntax:
SHRD destination, source, count
▸ Operand types:

SHRD reg16/32, reg16/32, imm8/CL

SHRD mem16/32, reg16/32, imm8/CL
21
SHRD Example
Shift count of 1:
mov al,11000001b
mov bl,00011101b
shrd al,bl,1

22
Another SHRD Example

Shift AX 4 bits to the right and replace its highest 4 bits with
the low 4 bits of DX:

mov ax,234Bh
mov dx,7654h Before:
shrd ax,dx,4
After:

23
Your turn . . .
Indicate the hexadecimal values of each destination
operand:

mov ax,7C36h
mov dx,9FA6h
shld dx,ax,4 ; DX = FA67h
shrd dx,ax,8 ; DX = 36FAh

24
What's Next
▸ Shift and Rotate Instructions
▸ Shift and Rotate Applications
▸ Multiplication and Division Instructions
▸ Extended Addition and Subtraction
▸ ASCII and Unpacked Decimal Arithmetic
▸ Packed Decimal Arithmetic

25
Shift and Rotate Applications
▸ Shifting Multiple Doublewords
▸ Binary Multiplication
▸ Displaying Binary Bits
▸ Isolating a Bit String

26
Shifting Multiple
Doublewords
▸ Programs sometimes need to shift all bits within an array, as one might
when moving a bitmapped graphic image from one screen location to
another.
▸ The following shifts an array of 3 doublewords 1 bit to the right (view
complete source code):
.data
ArraySize = 3
array DWORD ArraySize DUP(99999999h) ; 1001 1001...
.code
mov esi,0
shr array[esi + 8],1 ; high dword
rcr array[esi + 4],1 ; middle dword, include Carry
rcr array[esi],1 ; low dword, include Carry
27
Binary Multiplication
▸ mutiply 123 * 36

28
Binary Multiplication
▸ We already know that SHL performs unsigned multiplication efficiently
when the multiplier is a power of 2.
▸ You can factor any binary number into powers of 2.
▹ For example, to multiply EAX * 36, factor 36 into 32 + 4 and use the
distributive property of multiplication to carry out the operation:

EAX * 36 mov eax,123

= EAX * (32 + 4) mov ebx,eax
= (EAX * 32)+(EAX * 4) shl eax,5 ; mult by 25
shl ebx,2 ; mult by 22
add eax,ebx

29
Your turn . . .
Multiply AX by 26, using shifting and addition instructions.
Hint: 26 = 16 + 8 + 2.

mov ax,2 ; test value

mov dx,ax
shl dx,4 ; AX * 16
push edx ; save for later
mov dx,ax
shl dx,3 ; AX * 8
shl ax,1 ; AX * 2
add ax,dx ; AX * 10
pop edx ; recall AX * 16
add ax,dx ; AX * 26

30
What's Next
▸ Shift and Rotate Instructions
▸ Shift and Rotate Applications
▸ Multiplication and Division Instructions
▸ Extended Addition and Subtraction
▸ ASCII and Unpacked Decimal Arithmetic
▸ Packed Decimal Arithmetic

31
Multiplication and Division
Instructions
▸ MUL Instruction
▸ IMUL Instruction
▸ DIV Instruction
▸ Signed Integer Division
▸ CBW, CWD, CDQ Instructions
▸ IDIV Instruction
▸ Implementing Arithmetic Expressions
32
MUL Instruction
▸ The MUL (unsigned multiply) instruction multiplies an 8-, 16-, or 32-bit operand by either AL, AX,
or EAX.

▸ The instruction formats are:

MUL r/m8
MUL r/m16
MUL r/m32

33
MUL Examples
100h * 2000h, using 16-bit operands:
The Carry flag
.data indicates whether or
val1 WORD 2000h not the upper half of
val2 WORD 100h the product contains
.code significant digits.
mov ax,val1
mul val2 ; DX:AX = 00200000h, CF=1

12345h * 1000h, using 32-bit operands:

mov eax,12345h
mov ebx,1000h
mul ebx ; EDX:EAX = 0000000012345000h, CF=0

34
Your turn . . .
What will be the hexadecimal values of DX, AX, and the Carry
flag after the following instructions execute?

mov ax,1234h
mov bx,100h
mul bx

DX = 0012h, AX = 3400h, CF = 1

35
Your turn . . .
What will be the hexadecimal values of EDX, EAX, and the
Carry flag after the following instructions execute?

mov eax,00128765h
mov ecx,10000h
mul ecx

EDX = 00000012h, EAX = 87650000h, CF = 1

36
IMUL Instruction
▸ IMUL (signed integer multiply ) multiplies an 8-, 16-, or 32-bit signed
operand by either AL, AX, or EAX
▸ Preserves the sign of the product by sign-extending it into the upper
half of the destination register

Example: multiply 48 * 4, using 8-bit operands:

mov al,48
mov bl,4
imul bl ; AX = 00C0h, OF=1

OF=1 because AH is not a sign extension of AL.

37
IMUL Examples
Multiply 4,823,424 * −423:
mov eax,4823424
mov ebx,-423
imul ebx ; EDX:EAX = FFFFFFFF86635D80h, OF=0

OF=0 because EDX is a sign extension of EAX.

38
Your turn . . .
What will be the hexadecimal values of DX, AX, and the Carry
flag after the following instructions execute?

mov ax,8760h
mov bx,100h
imul bx

DX = FF87h, AX = 6000h, OF = 1

39
DIV Instruction
▸ The DIV (unsigned divide) instruction performs 8-bit, 16-bit, and 32-bit
division on unsigned integers
▸ A single operand is supplied (register or memory operand), which is
assumed to be the divisor
▸ Instruction formats:
DIV reg/mem8
DIV reg/mem16 Default Operands:
DIV reg/mem32

40
DIV Examples
Divide 8003h by 100h, using 16-bit operands:
mov dx,0 ; clear dividend, high
mov ax,8003h ; dividend, low
mov cx,100h ; divisor
div cx ; AX = 0080h, DX = 3

Same division, using 32-bit operands:

mov edx,0 ; clear dividend, high

mov eax,8003h ; dividend, low
mov ecx,100h ; divisor
div ecx ; EAX = 00000080h, DX = 3

41
Your turn . . .
What will be the hexadecimal values of DX and AX
after the following instructions execute? Or, if divide
overflow occurs, you can indicate that as your answer:

mov dx,0087h
mov ax,6000h
mov bx,100h
div bx

DX = 0000h, AX = 8760h

42
Your turn . . .
What will be the hexadecimal values of DX and AX
after the following instructions execute? Or, if divide
overflow occurs, you can indicate that as your answer:

mov dx,0087h
mov ax,6002h
mov bx,10h
div bx

Divide Overflow

43
Signed Integer Division (IDIV)
▸ Signed integers must be sign-extended before division takes place
▹ fill high byte/word/doubleword with a copy of the low
byte/word/doubleword's sign bit
▸ For example, the high byte contains a copy of the sign bit from the low
byte:

44
CBW, CWD, CDQ Instructions
▸ The CBW, CWD, and CDQ instructions provide important
sign-extension operations:
▹ CBW (convert byte to word) extends AL into AH
▹ CWD (convert word to doubleword) extends AX into DX
▹ CDQ (convert doubleword to quadword) extends EAX into EDX

▸ Example:
.data
dwordVal SDWORD -101 ; FFFFFF9Bh
.code
mov eax,dwordVal
cdq ; EDX:EAX = FFFFFFFFFFFFFF9Bh 45
IDIV Instruction
▸ IDIV (signed divide) performs signed integer division
▸ Same syntax and operands as DIV instruction

Example: 8-bit division of –48 by 5

mov al,-48
cbw ; extend AL into AH
mov bl,5
idiv bl ; AL = -9, AH = -3

46
IDIV Examples
Example: 16-bit division of –48 by 5
mov ax,-48
cwd ; extend AX into DX
mov bx,5
idiv bx ; AX = -9, DX = -3

Example: 32-bit division of –48 by 5

mov eax,-48
cdq ; extend EAX into EDX
mov ebx,5
idiv ebx ; EAX = -9, EDX = -3

47
Your turn . . .
What will be the hexadecimal values of DX and AX
after the following instructions execute? Or, if divide
overflow occurs, you can indicate that as your answer:

mov ax,0FDFFh ; -513

cwd
mov bx,100h
idiv bx

DX = FFFFh (−1), AX = FFFEh (−2)

48
Unsigned Arithmetic
Expressions
▸ Some good reasons to learn how to implement integer expressions:
▹ Learn how do compilers do it
▹ Test your understanding of MUL, IMUL, DIV, IDIV
▹ Check for overflow (Carry and Overflow flags)

Example: var4 = (var1 + var2) * var3

; Assume unsigned operands

mov eax,var1
add eax,var2 ; EAX = var1 + var2
mul var3 ; EAX = EAX * var3
jc TooBig ; check for carry
mov var4,eax ; save product 49
Signed Arithmetic
Expressions (1 of 2)
Example: eax = (-var1 * var2) + var3
mov eax,var1
neg eax
imul var2
jo TooBig ; check for overflow
add eax,var3
jo TooBig ; check for overflow

Example: var4 = (var1 * 5) / (var2 – 3)

mov eax,var1 ; left side
mov ebx,5
imul ebx ; EDX:EAX = product
mov ebx,var2 ; right side
sub ebx,3
idiv ebx ; EAX = quotient
mov var4,eax 50
Signed Arithmetic
Expressions (2 of 2)

Example: var4 = (var1 * -5) / (-var2 % var3);

mov eax,var2 ; begin right side

neg eax
cdq ; sign-extend dividend
idiv var3 ; EDX = remainder
mov ebx,edx ; EBX = right side
mov eax,-5 ; begin left side
imul var1 ; EDX:EAX = left side
idiv ebx ; final division
mov var4,eax ; quotient

Sometimes it's easiest to calculate the right-hand term of an

expression first.
51
Your turn . . .
Implement the following expression using signed 32-bit
integers:
eax = (ebx * 20) / ecx

mov eax,20
imul ebx
idiv ecx

52
Your turn . . .
Implement the following expression using signed 32-bit
integers. Save and restore ECX and EDX:
eax = (ecx * edx) / eax

push edx
push eax ; EAX needed later
mov eax,ecx
imul edx ; left side: EDX:EAX
pop ebx ; saved value of EAX
idiv ebx ; EAX = quotient
pop edx ; restore EDX, ECX

53
Your turn . . .
Implement the following expression using signed 32-bit
integers. Do not modify any variables other than var3:
var3 = (var1 * -var2) / (var3 – ebx)

mov eax,var1
mov edx,var2
neg edx
imul edx ; left side: EDX:EAX
mov ecx,var3
sub ecx,ebx
idiv ecx ; EAX = quotient
mov var3,eax

54
What's Next
▸ Shift and Rotate Instructions
▸ Shift and Rotate Applications
▸ Multiplication and Division Instructions
▸ Extended Addition and Subtraction
▸ ASCII and UnPacked Decimal Arithmetic
▸ Packed Decimal Arithmetic

55
Extended Addition and
Subtraction
▸ ADC Instruction
▸ Extended Precision Addition
▸ SBB Instruction
▸ Extended Precision Subtraction

56
Extended Precision Addition
▸ Adding two operands that are longer than the computer's word size (32
bits).
▹ Virtually no limit to the size of the operands
▸ The arithmetic must be performed in steps
▹ The Carry value from each step is passed on to the next step.

57
ADC Instruction
▸ ADC (add with carry) instruction adds both a source operand and the
contents of the Carry flag to a destination operand.
▸ Operands are binary values
▹ Same syntax as ADD, SUB, etc.
▸ Example
▹ Add two 32-bit integers (FFFFFFFFh + FFFFFFFFh), producing a
64-bit sum in EDX:EAX:
mov edx,0
mov eax,0FFFFFFFFh
add eax,0FFFFFFFFh
adc edx,0 ;EDX:EAX = 00000001FFFFFFFEh
58
Extended Addition Example
▸ Task: Add 1 to EDX:EAX
▹ Starting value of EDX:EAX: 00000000FFFFFFFFh
▹ Add the lower 32 bits first, setting the Carry flag.
▹ Add the upper 32 bits, and include the Carry flag.

mov edx,0 ; set upper half

mov eax,0FFFFFFFFh ; set lower half
add eax,1 ; add lower half
adc edx,0 ; add upper half

EDX:EAX = 00000001 00000000

59
SBB Instruction
▸ The SBB (subtract with borrow) instruction subtracts both a source
operand and the value of the Carry flag from a destination operand.
▸ Operand syntax:
▹ Same as for the ADC instruction

60
Extended Subtraction
Example
▸ Task: Subtract 1 from EDX:EAX
▹ Starting value of EDX:EAX: 0000000100000000h
▹ Subtract the lower 32 bits first, setting the Carry flag.
▹ Subtract the upper 32 bits, and include the Carry flag.

mov edx,1 ; set upper half

mov eax,0 ; set lower half
sub eax,1 ; subtract lower half
sbb edx,0 ; subtract upper half

EDX:EAX = 00000000 FFFFFFFF

61
Summary
▸ Shift and rotate instructions are some of the best tools of assembly
language
▹ finer control than in high-level languages
▹ SHL, SHR, SAR, ROL, ROR, RCL, RCR
▸ MUL and DIV – integer operations
▹ close relatives of SHL and SHR
▹ CBW, CDQ, CWD: preparation for division
▸ Extended precision arithmetic: ADC, SBB
▸ ASCII decimal operations (AAA, AAS, AAM, AAD)
▸ Packed decimal operations (DAA, DAS) 62
THANKS!
Any questions?
You can find me at:
▸ A.qadeer@nu.edu.pk
▸ Office #213, Visiting Hours Only

63