Chapt 07 KIP Irvine
Chapt 07 KIP Irvine
MUL Instruction IMUL Instruction DIV Instruction Signed Integer Division 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 val1 WORD 2000h val2 WORD 100h .code mov ax,val1 mul val2 ; DX:AX = 00200000h, CF=1
The Carry flag indicates whether or not the upper half of the product contains significant digits.
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
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
IMUL Examples
Multiply 4,823,424 * 423:
mov eax,4823424 mov ebx,-423 imul ebx
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
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 DIV r/m32
Default Operands:
DIV Examples
Divide 8003h by 100h, using 16-bit operands:
mov mov mov div dx,0 ax,8003h cx,100h cx ; ; ; ; clear dividend, high dividend, low divisor AX = 0080h, DX = 3
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 mov mov div dx,0087h ax,6000h bx,100h bx
DX = 0000h, AX = 8760h
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 mov mov div dx,0087h ax,6002h bx,10h bx
Divide Overflow
12
For example, the high byte contains a copy of the sign bit from the low byte:
10001111
11111111
10001111
13
For example:
mov eax,0FFFFFF9Bh cdq ; EDX:EAX = FFFFFFFFFFFFFF9Bh
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 mov bl,5 idiv bl ; extend AL into AH ; AL = -9, AH = -3
15
IDIV Examples
Example: 16-bit division of 48 by 5
mov ax,-48 cwd mov bx,5 idiv bx ; extend AX into DX ; AX = -9, DX = -3
16
(1 of 3)
Learn how do compilers do it Test your understanding of MUL, IMUL, DIV, and IDIV Check for overflow
17
(2 of 3)
(3 of 3)
19
Your turn . . .
Implement the following expression using signed 32-bit integers:
eax = (ebx * 20) / ecx
mov eax,20 imul ebx idiv ecx
20
Your turn . . .
Implement the following expression using unsigned 32bit integers. Save and restore ECX and EDX:
eax = (ecx * edx) / ecx
push push push mov mul pop div pop pop ecx edx eax eax,ecx edx ecx ecx edx ecx
; EAX needed later ; ; ; ; left side: EDX:EAX saved value of EAX EAX = quotient restore EDX, ECX
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 mov ecx,var3 sub ecx,ebx idiv ecx mov var3,eax
; eax = quotient
22
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 mov add adc edx,0 eax,0FFFFFFFFh eax,0FFFFFFFFh edx,0
;EDX:EAX = 00000001FFFFFFFEh
24
; restore the Carry flag ; repeat the loop ; add any leftover carry
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 mov sub sbb edx,1 eax,0 eax,1 edx,0 ; ; ; ; upper half lower half subtract 1 subtract upper half
26
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
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
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
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
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 mov al,06h mul bl aam ; ; ; ; first operand second operand AX = 001Eh AX = 0300h
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 aad mov bl,5 div bl mov quotient,al mov remainder,ah
; ; ; ;
33
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 daa
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 das ; AL = 3Dh ; AL = 37h (adjusted)
36