Scribd
Upload
28 views27 pages

Lecture - 13

Uploaded by

Gamer Boiii
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
28 views27 pages

Lecture - 13

Uploaded by

Gamer Boiii
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 27

Computer Organization &

Assembly Languages

Multiplication and Division Instructions

Imran Ahmad Qureshi


[email protected]
Multiplication and Division Instructions
■ MUL Instruction
■ IMUL Instruction
■ DIV Instruction
■ Signed Integer Division
■ CBW, CWD, CDQ Instructions
■ IDIV Instruction
■ Implementing Arithmetic Expressions
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
Implied operands:
MUL Examples
100h * 2000h, using 16-bit operands:
.data The Carry flag
val1 WORD 2000h
indicates whether
val2 WORD 100h
.code
or not the upper
mov ax,val1 half of the product
mul val2 ; DX:AX = 00200000h, CF=1 contains
significant digits.

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

mov eax,12345h
mov ebx,1000h
mul ebx ; EDX:EAX = 0000000012345000h, CF=0
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
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


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: 8-bit signed multiplication (48 × 4):
mov al,48 ; 110000
mov bl,4
imul bl ; AX = 00C0h, OF=1

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


that the signed result does not fits within AL.
IMUL Examples
8-bit signed multiplication of (-4 × 4):

mov al,-4
mov bl,4
imul bl ; AX = FFF0h, OF=0

OF=0 because AH is a sign extension of AL, meaning


that the signed result fits within AL
IMUL Examples
16-bit signed multiplication (48 × 4):

mov ax,48
mov bx,4
imul bx ; DX:AX = 0000h:00C0h , OF = 0

OF=0 because DX is a sign extension of AX, meaning


that the signed result fits within AL
IMUL Examples
32-bit signed multiplication (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.


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
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 r/m8 Default Operands:
DIV r/m16
DIV r/m32
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, EDX = 3
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
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
Divide Overflow

■ Divide overflow happens when the quotient is


too large to fit into the destination.
mov ax, 1000h
mov bl, 10h
div bl
It causes a CPU interrupt and halts the program.
(divided by zero cause similar results)
Signed Integer Division
■ 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: 1 0 0 0 1 1 1
1

11111111 1000111
1
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:
mov eax,0FFFFFF9Bh ; (-101)
cdq ; EDX:EAX = FFFFFFFFFFFFFF9Bh
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
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
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 ; 256 idiv bx

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


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
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
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.
Your turn . . .
Implement the following expression using signed 32-bit
integers:
eax = (ebx * 20) / ecx

mov eax,20
imul ebx
idiv ecx
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
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

You might also like