0% found this document useful (0 votes)
240 views36 pages

Assembly Examples To Solve PDF

This document discusses instructions for multiplication, division, and arithmetic expressions in assembly language. It covers: - MUL and IMUL instructions for unsigned and signed multiplication - DIV and IDIV instructions for unsigned and signed division - How to implement signed integer arithmetic using sign extension via CBW, CWD, CDQ - Examples of multiplying, dividing, and arithmetic expressions in assembly along with checking for overflow - How compilers implement arithmetic expressions by breaking them into individual MUL, DIV, ADD etc operations.
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
0% found this document useful (0 votes)
240 views36 pages

Assembly Examples To Solve PDF

This document discusses instructions for multiplication, division, and arithmetic expressions in assembly language. It covers: - MUL and IMUL instructions for unsigned and signed multiplication - DIV and IDIV instructions for unsigned and signed division - How to implement signed integer arithmetic using sign extension via CBW, CWD, CDQ - Examples of multiplying, dividing, and arithmetic expressions in assembly along with checking for overflow - How compilers implement arithmetic expressions by breaking them into individual MUL, DIV, ADD etc operations.
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/ 36

Multiplication and Division Instructions

• MUL Instruction
• IMUL Instruction
• DIV Instruction
• Signed Integer Division
• Implementing Arithmetic Expressions

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 1


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:

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 2


MUL Examples

100h * 2000h, using 16-bit operands:


.data
val1 WORD 2000h The Carry flag
indicates whether or
val2 WORD 100h
not the upper half of
.code the product contains
mov ax,val1 significant digits.
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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 3


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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 4


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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 5


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.

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 6


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.

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 7


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

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

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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 8


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
DIV r/m16
Default Operands:
DIV r/m32

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 9


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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 10


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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 11


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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 12


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:

10001111

11111111 10001111

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 13


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
• For example:
mov eax,0FFFFFF9Bh
cdq ; EDX:EAX = FFFFFFFFFFFFFF9Bh

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 14


IDIV Instruction

• IDIV (signed divide) performs signed integer division


• Uses same operands as DIV

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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 15


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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 16


Implementing Arithmetic Expressions (1 of 3)

• Some good reasons to learn how to implement


expressions:
• Learn how do compilers do it
• Test your understanding of MUL, IMUL, DIV, and IDIV
• Check for overflow

Example: var4 = (var1 + var2) * var3


mov eax,var1
add eax,var2
mul var3
jo TooBig ; check for overflow
mov var4,eax ; save product

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 17


Implementing Arithmetic Expressions (2 of 3)

Example: eax = (-var1 * var2) + var3


mov eax,var1
neg eax
mul var2
jo TooBig ; check for overflow
add eax,var3

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


mov eax,var1 ; left side
mov ebx,5
mul ebx ; EDX:EAX = product
mov ebx,var2 ; right side
sub ebx,3
div ebx ; final division
mov var4,eax

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 18


Implementing Arithmetic Expressions (3 of 3)

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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 19


Your turn . . .

Implement the following expression using signed 32-bit


integers:
eax = (ebx * 20) / ecx

mov eax,20
imul ebx
idiv ecx

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 20


Your turn . . .

Implement the following expression using unsigned 32-


bit integers. Save and restore ECX and EDX:
eax = (ecx * edx) / ecx

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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 21


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

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 22


Extended ASCII Addition and Subtraction

• ADC Instruction
• Extended Addition Example
• SBB Instruction

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 23


ADC Instruction
• ADC (add with carry) instruction adds both a source
operand and the contents of the Carry flag to a
destination operand.
• Example: Add two 32-bit integers (FFFFFFFFh +
FFFFFFFFh), producing a 64-bit sum:
mov edx,0
mov eax,0FFFFFFFFh
add eax,0FFFFFFFFh
adc edx,0 ;EDX:EAX = 00000001FFFFFFFEh

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 24


Extended Addition Example
• Add two integers of any size
• Pass pointers to the addends and sum
• ECX indicates the number of doublewords
L1: mov eax,[esi] ; get the first integer
adc eax,[edi] ; add the second integer
pushfd ; save the Carry flag
mov [ebx],eax ; store partial sum
add esi,4 ; advance all 3 pointers
add edi,4
add ebx,4
popfd ; restore the Carry flag
loop L1 ; repeat the loop
adc word ptr [ebx],0 ; add any leftover carry

View the complete source code.

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 25


SBB Instruction
• The SBB (subtract with borrow) instruction subtracts both a
source operand and the value of the Carry flag from a
destination operand.
• The following example code performs 64-bit subtraction. It sets
EDX:EAX to 0000000100000000h and subtracts 1 from this
value. The lower 32 bits are subtracted first, setting the Carry
flag. Then the upper 32 bits are subtracted, including the Carry
flag:
mov edx,1 ; upper half
mov eax,0 ; lower half
sub eax,1 ; subtract 1
sbb edx,0 ; subtract upper half

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 26


ASCII and Packed Decimal Arithmetic

• Unpacked BCD
• ASCII Decimal
• AAA Instruction
• AAS Instruction
• AAM Instruction
• AAD Instruction
• Packed Decimal Integers
• DAA Instruction
• DAS Instruction

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 27


Unpacked BCD

• Binary-coded decimal (BCD) numbers use 4 binary


bits to represent each decimal digit
• A number using unpacked BCD representation stores
a decimal digit in the lower four bits of each byte
• For example, 5,678 is stored as the following sequence
of hexadecimal bytes:

05 06 07 08

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 28


ASCII Decimal

• A number using ASCII Decimal representation stores


a single ASCII digit in each byte
• For example, 5,678 is stored as the following sequence
of hexadecimal bytes:
35 36 37 38

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 29


AAA Instruction
• The AAA (ASCII adjust after addition) instruction
adjusts the binary result of an ADD or ADC
instruction. It makes the result in AL consistent with
ASCII digit representation.
• The Carry value, if any ends up in AH
• Example: Add '8' and '2'
mov ah,0
mov al,'8' ; AX = 0038h
add al,'2' ; AX = 006Ah
aaa ; AX = 0100h (adjust result)
or ax,3030h ; AX = 3130h = '10'

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 30


AAS Instruction
• The AAS (ASCII adjust after subtraction) instruction
adjusts the binary result of an SUB or SBB instruction. It
makes the result in AL consistent with ASCII digit
representation.
• It places the Carry value, if any, in AH
• Example: Subtract '9' from '8'

mov ah,0
mov al,'8' ; AX = 0038h
sub al,'9' ; AX = 00FFh
aas ; AX = FF09h (adjust result)
pushf ; save Carry flag
or al,30h ; AX = FF39h (AL = '9')
popf ; restore Carry flag

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 31


AAM Instruction
• The AAM (ASCII adjust after multiplication) instruction
adjusts the binary result of a MUL instruction. The
multiplication must have been performed on
unpacked decimal numbers.

mov bl,05h ; first operand


mov al,06h ; second operand
mul bl ; AX = 001Eh
aam ; AX = 0300h

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 32


AAD Instruction
• The AAD (ASCII adjust before division) instruction
adjusts the unpacked decimal dividend in AX before
a division operation

.data
quotient BYTE ?
remainder BYTE ?
.code
mov ax,0307h ; dividend
aad ; AX = 0025h
mov bl,5 ; divisor
div bl ; AX = 0207h
mov quotient,al
mov remainder,ah

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 33


Packed Decimal Integers

• Packed BCD stores two decimal digits per byte


• For example, 12,345,678 can be stored as the
following sequence of hexadecimal bytes:

12 34 56 78

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 34


DAA Instruction
• The DAA (decimal adjust after addition) instruction
converts the binary result of an ADD or ADC
operation to packed decimal format.
• The value to be adjusted must be in AL
• Example: calculate BCD 35 + 48

mov al,35h
add al,48h ; AL = 7Dh
daa ; AL = 83h (adjusted)

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 35


DAS Instruction

• The DAS (decimal adjust after subtraction) instruction


converts the binary result of a SUB or SBB operation
to packed decimal format.
• The value must be in AL
• Example: subtract BCD 48 from 85

mov al,85h
sub al,48h ; AL = 3Dh
das ; AL = 37h (adjusted)

Irvine, Kip R. Assembly Language for Intel-Based Computers, 2003. 36

You might also like