lecture 5 multiplication, division and branches dr. dimitrios s. nikolopoulos csl/uiuc
TRANSCRIPT
By now you should be able to…
• Move data between registers and memory• Address memory in 17 ways• Use logic and shifting operations to
– Apply bit masks – Multiple with sums of powers of two– Divide by powers of two
• Use addition and subtraction with both signed and unsigned numbers
• Organize simple programs
Unsigned Multiplication
• MUL X, where X can be register or memory location• Poor choice of the architects because they ran out of
opcodes…• Second argument is implicit, it is stored in
– AL if X is 8-bit number– AX if X is 16-bit number– EAX if X is 32-bit number
• Result stored in– AX if arguments are 8-bit– DX:AX if arguments are 16-bit– EDX:EAX if arguments are 32-bit
The mess with flags
• The values of A,S,Z,P are undefined after multiplication
• This means that you cannot check the Z flag to see if the result is 0!
• You have to compare the result with the value 0 using a CMP instruction
• The C and O flags are cleared if the result fits in a half-size register
Signed Multiplication
• The architects tried to apologize for the inconvenience in 80286 and later processors
• 2’s complement signed integers• IMUL reg/mem • IMUL reg, reg/mem• IMUL reg, immediate• IMUL reg, reg/mem, immediate data
Signed Multiplication
• IMUL X behaves like MUL• IMUL A, B computes A=A*B• IMUL A,B,C computes A=B*C• There is no 8-bit by 8-bit multiplication, last operand
may be 8-bit• The instruction does not produce a 2n bit result
so 16-bit by 16-bit produces as 16-bit number • When the result does not fit in half-sized register the
instruction sets the C and O flags• What a mess…
Simple Examples
• IMUL BL ; AX=AL*BL, single operand like MUL• IMUL BX ; DX:AX=BX*AX, single operand like
MUL• IMUL CX,DX,12h ; CX=DX*12h, result in 16-bit CX
Use of MUL/IMUL
• Accessing multidimensional arrays• Let A a NxM array of words with row-major ordering• A[I,J] is accessed as A+(I*M+J)*2• Let a NxMxO array of words with row-major ordering• A[I,J,K] is accessed as A+((I*M+J)*O+K)*2• It is convenient but it is slow
Unsigned division
• DIV X, X register or memory• Nominator is implicit, stored in AX if X 8-bit, DX:AX if
X is 16-bit, EDX:EAX is X is 32-bit• If X 8-bit quotient is stored in AL and remainder in AH• If X 16-bit quotient is stored in AX and remainder in
DX• If X 32-bit quotient in stored in EAX and remainder in
EDX
Dividing equally sized words
• Use sign-extension of the nominator• Special instructions for sign extensions• CBW (Convert Byte to Word)
– Before: AX=xxxx xxxx snnn nnnn– After: AX=ssss ssss snnn nnnn
• CWD (Convert Word to Double Word)– Before AX=snnn nnnn nnnn nnnn– After DX=ssss ssss ssss ssss AX=snnn nnnn nnnn nnnn
• CWDE– Similar to CWD but sign extends in EAX instead of DX
Flags
• Division just scrambles the flags• Division by 0 though produces an interrupt by the
microprocessor (more on interrupts next week)• If the quotient does not fit in the register, this also
produces an interrupt• E.g. 1000/2=500, argument (2) is 8-bit but quotient
(500) does not fit in AL, there is a divide overflow and an interrupt is produced
Rounding
• We get rid of the remainder when we want to truncate the result
• We can double the remainder, compare it to the denominator and then adjust the quotient– If (remainder*2) > denominator, increment quotient
Unconditional Jumps
• Transfer the control flow of the program to a specified instruction, other than the next instruction in sequential execution
• Jumps are performed with labels pointing to the address of the target instruction
• It is the equivalent of a goto statement• Goto is good in assembly!
Unconditional jumps
• Short jump– JMP SHORT label, where label is within –128/+127 bytes off
the current instruction
• Near jump– JMP label, where label is within –32,768/+32,767 bytes off
the current instruction
• Far jump– JMP label, where label is any memory address, in
segment:offset format
• In protected mode near and far jumps are the same
Conditional Jumps
• Jumps performed if a condition evaluates to true• Conditions are evaluated based on the values of the
bits in the FLAGS register • Test S, Z, P, C, O• If condition is true the jump is performed to the
location specified• If condition is false the code proceeds with the next
instruction in sequence• Short or near jumps in 80386
Comparisons
• CMP A, B • Executes A-B without modifying A (non-destructive)• CMP is most of the time followed by a conditional
jump based on the outcome of the comparisonCMP AL, 10h ; If AL >= 10 jump
JAE target
• CMP is a non-destructive SUB, it sets the flags exactly like the SUB instruction
Comparisons
• Unsigned A,B– If (A<B), C=1– If (A>B), C=0– Z tested for equality/inequality
• Signed A,B– If (S XOR O = = 1) A<B else A>B– Z tested for equality/inequality
Signed comparisons
• Case 1, Sign=1, Overflow=0– A-B looks negative– There is no overflow, so A<B
• Case 2, Sign=0, Overflow=1– A-B looks positive– But there is overflow so the sign bit is wrong and A<B
• Case 3, Sign=0, Overflow=0– A-B looks positive– No overflow, so A>B
• Case 4, Sign=1, Overflow=1– A-B looks negative– But overflow bit is set so the sign flag is wrong therefore A>B
Conditional Jumps
• Syntax: JX, where X denotes the condition• J -> Jump• N -> Not• E -> Equal• A/B -> Above/Below for unsigned arithmetic• G/L -> Greater/Less for signed arithmetic
Conditional jump instructions
• JL, jump if less– Jumps if A<B, that is if S XOR O = 1
• JA, JNBE (above == not (below or equal))– Jumps if C=0&Z=0
• JBE, JNA (below or equal == not above)– Jumps if Z=1 | C=1
• JAE, JNB, JNC (above or equal == not below==no carry)– C=0
Conditional jump instructions
• JB, JNA, JC (below == not above == carry set)– C=1
• JE, JZ (equal == result is 0)– Z=1
• JNE, JNZ (not equal == result is not 0)– Z=0
• JNS (sign, no sign)– S=0
• JO– O=1
• JS– S=1
Conditional jump instructions
• JNO– O=0
• JG, JNLE (greater==not (less or equal))– S=0, Z=0
• JGE, JNL (greater or equal == not less)– S=0
• JL, JNGE (less == not (greater or equal))– S XOR O = 1
• JLE, JNG (less or equal == not greater)– (S XOR O = 1) | Z=1
• JCXZ (counter register is 0), useful for loops
Loops
• LOOP label – Combination of CMP and JNZ
• Decrement the CX register and if register has not become 0 jump to the specified label
• If CX becomes 0 the instruction following the LOOP instruction is executed
Example
ADDSmov cx, 100 ;load countmov si, BLOCK1mov di, BLOCK2
.Againlodsw ;get Block1 data
; AX = [SI]; SI = SI + 2
add AX, [ES:DI] ;add Block2 data
stosw ;store in Block2; [DI] = AX; DI = DI + 2
loop .Again ;repeat 100 times
ret
If then else in assembly
mov ax, [a]
mov bx, [b]
cmp ax,bx
ja .true
; false instructions
jmp .done
.true
; true instructions
If (a>b) {
/* true instructions */
} else {
/* false instructions */
}
Switch in assembly
cmp al, ‘a’jne .b; these are the ‘a’
instructions jmp .done.bcmp al, ‘b’jne .default; these are the ‘b’
instructions.default;default instructions.done
switch (var) {case ‘a’:/* a instructions */break;case ‘b’:/* b instructions */break;default/* default instructions */
}
Do while in assembly
.begin
; instructions…
mov ax, [a]
mov bx, [b]
cmp a,b
je .begin
do {
/* instructions */
} while (a==b);
While do in assemblyWhile do in assembly
.begin.begin
mov ax, [a]mov ax, [a]
mov bx, [b]mov bx, [b]
cmp ax,bxcmp ax,bx
jne .donejne .done
; instructions; instructions
jmp beginjmp begin
.done.done
while (a==b) {while (a==b) {
/* instructions *//* instructions */
};};
Examples;; while (J >= K) do beginwhile (J >= K) do begin
;; J := J - 1;J := J - 1;
;; K := K + 1;K := K + 1;
;; L := J * K;L := J * K;
;; end;end;
.WhlLoop:.WhlLoop:movmov ax, [J]ax, [J]cmpcmp ax, [K]ax, [K]jngejnge .QuitLoop.QuitLoopdecdec word [J]word [J]incinc word [K]word [K]movmov ax, [J]ax, [J]imulimul [K][K]movmov [L], ax[L], axjmpjmp .WhlLoop.WhlLoop
.QuitLoop:.QuitLoop:
;; if (J <= K) thenif (J <= K) then
;; L := L + 1L := L + 1
;; elseelse L := L - 1L := L - 1
; ; J, K, L are signed J, K, L are signed wordswords
movmov ax, [J]ax, [J]
cmpcmp ax, [K]ax, [K]
jneljnel .DoElse.DoElse
incinc word [L]word [L]
jmpjmp .ifDone.ifDone
.DoElse:.DoElse:
decdec word [L]word [L]
.ifDone:.ifDone: