Multiplication and Division Instructions MUL Instruction IMUL Instruction

Multiplication and Division Instructions • • MUL Instruction IMUL Instruction DIV Instruction Signed Integer Division CBW, CWD, CDQ Instructions IDIV Instruction Implementing Arithmetic Expressions Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 1

MUL Instruction • In 32 -bit mode, MUL (unsigned multiply) instruction multiplies an 8 -, 16 -, or 32 -bit operand by either AL, AX, or EAX. • The instruction formats are: MUL r/m 8 MUL r/m 16 MUL r/m 32 Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 2

MUL Examples 100 h * 2000 h, using 16 -bit operands: . data val 1 WORD 2000 h val 2 WORD 100 h. code mov ax, val 1 mul val 2 ; DX: AX = 00200000 h, CF=1 The Carry flag indicates whether or not the upper half of the product contains significant digits. 12345 h * 1000 h, using 32 -bit operands: mov eax, 12345 h mov ebx, 1000 h mul ebx ; EDX: EAX = 000012345000 h, CF=0 Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 3

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 The Overflow flag indicates whether or not the upper half of the product contains significant digits. Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 4

IMUL Examples • Multiply 10 * 3, using 8 -bit operands: mov al, 10 mov bl, 3 imul bl ; AX = 001 Eh (or +30), OF=0 • Multiply 10 * (-3), using 8 -bit operands: mov al, 10 mov bl, -3 imul bl ; AX = FFE 2 h (or -30), OF=0 • In both cases, OF == 0 • Meaning that AH is a sign extension of value in AL • AH can be ignored! Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 5

IMUL Instruction Example: multiply 48 * 4, using 8 -bit operands: mov al, 48 mov bl, 4 imul bl ; AX = 00 C 0 h (or +192), OF=1 because AH is NOT a sign extension of AL Can’t ignore AH!!! (AL, by itself, would be incorrectly interpreted as -64) Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 6

Same Example: multiply 48 * 4, using 16 -bit operands: mov ax, 48 mov bx, 4 imul bx ; DX: AX = 000000 C 0 h (or +192), OF=0 because AH is a sign extension of AL • can ignore DX!!! Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 7

IMUL Examples Multiply 4, 823, 424 * -423: mov eax, 4823424 mov ebx, -423 imul ebx ; EDX: EAX = FFFF 86635 D 80 h, OF=0 because EDX is a sign extension of EAX. Example: Multiply Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 8

Two Operand Versions • Both MUL and IMUL have versions that take two operands for 16 and 32 bit multiplications (not the 8 bit version!) • The first operand is a register that is used for the multiplicand (instead of AX or EAX) • The second operand is the multiplier, as shown before • Result gets truncated to the size of the destination register!!! • Be sure to check CF and OF!!! mov cx, 10 ; cx is used mov bx, -3 ; instead of ax imul cx, bx Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. Note: there also three operand versions! 9

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/mem 8 DIV reg/mem 16 DIV reg/mem 32 Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. Default Operands: 10

DIV Examples Divide 8003 h by 100 h, using 16 -bit operands: mov mov div dx, 0 ax, 8003 h cx, 100 h cx ; AX = ; clear dividend, high ; set dividend, low ; divisor 0080 h, DX = 3 Same division, using 32 -bit operands: mov mov div edx, 0 ; eax, 8003 h ; ecx, 100 h ; ecx ; clear dividend, high set dividend, low divisor EAX = 00000080 h, DX = 3 Example: Primes Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 11

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: Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 12

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 dword. Val SDWORD -101 ; FFFFFF 9 Bh. code mov eax, dword. Val cdq ; EDX: EAX = FFFFFFF 9 Bh Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 13

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 mov bl, 5 idiv bl Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. ; extend AL into AH ; AL = -9, AH = -3 14

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 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 x 86 Processors 7/e, 2015. 15

Divide Overflow • An overflow condition is created when the result is too large to fit in the destination operand mov ax, 0 FFFh ; (4095) mov bl, 02 h div bl ; (4095/2 = 2047, R= 1) 2047 = 07 FFh - won't fit in AL - DIVIDE OVERFLOW!!! • Divide overflow causes program to abort • One solution is to use larger operands!!! Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 16

Unsigned Arithmetic Expressions • Some good reasons to learn how to implement integer expressions: • Learn how compilers do it • Test your understanding of MUL, IMUL, DIV, IDIV • Check for overflow (Carry and Overflow flags) Example: var 4 = (var 1 + var 2) * var 3 ; Assume unsigned operands mov eax, var 1 add eax, var 2 ; EAX = var 1 + var 2 mul var 3 ; EAX = EAX * var 3 jc Too. Big ; check for carry mov var 4, eax ; save product Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 17

Signed Arithmetic Expressions (1 of 2) Example: eax = (-var 1 * var 2) + var 3 mov neg imul jo add jo eax, var 1 eax var 2 Too. Big ; check for overflow eax, var 3 Too. Big ; check for overflow Example: var 4 = (var 1 * 5) / (var 2 – 3) mov imul mov sub idiv mov eax, var 1 ; left side ebx, 5 ebx ; EDX: EAX = product ebx, var 2 ; right side ebx, 3 ebx ; EAX = quotient var 4, eax Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 18

Signed Arithmetic Expressions (2 of 2) Example: var 4 = (var 1 * -5) / (-var 2 % var 3); mov neg cdq idiv mov imul idiv mov eax, var 2 ; begin right side eax ; sign-extend dividend var 3 ; EDX = remainder ebx, edx ; EBX = right side eax, -5 ; begin left side var 1 ; EDX: EAX = left side ebx ; final division var 4, eax ; quotient Sometimes it's easiest to calculate the right-hand term of an expression first. Irvine, Kip R. Assembly Language for x 86 Processors 7/e, 2015. 19