Arithmetic and Logic Instructions

Thorne : Chapter 6, 7, 9
(Irvine, Edition IV : 4.1, 4.2, 6.2 7.2, 7.3, 7.4)

SYSC3006 1
 Breakdown of Intel 8086 Assembly Instructions

1. Data transfer: copy data among state variables (registers,

memory and I/O ports)
• Their execution do not modify FLAGS
• eg.
g MOV instruction
2. Data manipulation: modify state variable values
• Executed within the ALU data path
• Their execution do modify the FLAGS
• eg. Arithmetic : ADD, SUB, CMP
• eg. Logical : AND, OR, NOT, XOR
• eg. Shift, Rotate : SHL, SAR, RCL, ROL
3. Control-flow: determine “next” instruction to execute
• Their execution allow non-sequential
q execution
• eg. JMP and JE
SYSC3006 2
 Data Manipulation Instructions
Compute new value … modify flags
Some common flag results :
ZF = zero flag set iff result = 0
CF = carry
C c y flagg reflect
e ec carry
c y value
v ue set = 11, clear = 0
SF = sign flag set iff result < 0
assumes 2’s complement
p encoding!
g iff ==If-and-only-if
y
OF = overflow flag
set iff signed
g overflow
specific use of “overflow” – not
the same as the general concept!

SYSC3006 3
 Signed versus Unsigned Arithmetic

• These operations perform a bitwise add/subtract of values of

width n to give a result of width n

• 8-bit Unsigned Integer Examples:

11710 = 0111 01012
+ 9910 = 0110 00112
21610 = 1101 10002

13310 = 1000 01012

– 5110 = 0011 00112
8210 = 0101 00102

SYSC3006 4
Arithmetic Operations : Binary Addition and Subtraction
8-bit Signed Integer Examples:

• The computer does exactly the same thing for 2’s complement
signed integers! ☺
Signed is now being
-11710 = 1000 10112 used to mean 2’s
complement signed
+ 9910 = + 0110 00112
- 1810 = 1110 11102 ( 0001 00012 +1 = 12h=18d)

-32
3210 = 1110 00002
– 510 = – 0000 01012
-3710 = 1101 10112 ( 0010 01002 +1 = 25h=37d)

SYSC3006 5
Arithmetic Operations : Binary Addition and Subtraction

Computers often implement subtraction using “negate and add”

X – Y = X + (– Y)

Example : 32 –65 = 32 + (-65)

3210 = 0010 00002

+ – 6510 = + 1011 11112 ( 0100 00002 +1 = 41h = 65d)
– 3310 = 1101 11112 ( 0010 00002 +1 = 21h = 33d)

SYSC3006 6
 Overflow : The Concept

Overflow : Result of operation outside the range that can be

represented
– Problem
bl arising
i i due
d to limited
li i d range off fixed-width
fi d id h
representation.
– Result is still produced; the result is just meaningless.
• 8-bit Unsigned Integer Example:
What is the range of
25510 = 1111 11112 an 8-bit unsigned
We need 9
bits to + 110 = 0000 00012 number ?
represent the 256 ?? 010 = (1) 0000 00002
result
CARRY
– IIn thi
this case ((with
ith fixed
fi d 8-bits)
8 bit ) : OVERFLOW OCCURRED!
CF=1
– In this case (unsigned) : A carry @ MSB is important in the
INTERPRETATION off the h result.
l
SYSC3006 7
 Addition and Subtraction Overflow
Is that the only interpretation of the example?

1111 11112 ( = – 110) Same binary pattern !

+ 0000 00012 ( = + 110)
(1) 0000 00002 ( = 010)

• What if the values are interpreted as 8-bit signed integers ?

– The result is correct ( – 1 + 1 = 0 ). There is no overflow.
OF=0 (CF=1)
– In this case (signed), the carry at MSB still occurs but is not
important to the interpretation!
– ZF = ? SF = ?

Overflow:
• Carry flag (CF) for unsigned numbers
• Overflow flag (OF) for singed numbers

SYSC3006 8
 Addition and Subtraction Overflow

Another example : With Borrow

8-bit result 3210 = 0010 00002 8 bit result

8-bit lt
– 6510 = 0100 00012
– 3310 = 1 1101 11112 ( = + 22310 : unsigned)
( = – 3310 : signed)
i d)

• If the values are interpreted

p as unsigned,
g the borrow implies
p
overflow (actually, underflow) : the result is WRONG.
• If the value are interpreted as signed, there is no overflow;
ignore
g the borrow : the result is CORRECT. CF = 1
OF = 0
SYSC3006 SF = 1 9
ZF = 0
 Addition and Subtraction Overflow

Overflow depends on the interpretation of the values.

Another
A th example:
l unsigned
i d signed
i d
0111 11112 127 127
+ 0000 00012 + 1 + 1
1000 00002 128 – 128
CORRECT WRONG
OVERFLOW …
CF = 0 (CF → unsigned number) even though
OF = 1 (OF → signed number) there is no carry
SF = 1 outside
id off fixed
fi d
width!
SYSC3006 10
 Overflow Cookie Cutters

Unsigned: Carry or borrow means overflow

0 2N-1
borrow carry

Signed : Ignore carry or borrow

Overflow possible if :
positive + positive = negative
( ppositive – negative
g = negative
g )
negative + negative = positive
( negative – positive = positive )
Overflow impossible if :
positive + negative ( positive – positive )
negative + positive (negative – negative )

SYSC3006 11
 Data Manipulation : ADD

Example: Suppose that AL contains 73H, when it is executed :

execute: ADD AL, 40H
73 H + 40 H
= B3H carry?
results: AL := B3H ( = 1011 0011 B))
ZF := 0 result ≠ 0
SF := 1 result is negative (signed)
CF := 0 (no carry out of msbit)
OF := 1 +ve + +ve = −ve
Correct result for unsigned number (CF = 0)
Wrong result for signed number (OF = 1)
SYSC3006 12
Problem : Write a program to perform the following operation :
z = x + y where x = 55667788h and y = 99669988h
Solution:
.data
x DW 7788h
DW 5566h
y DW 9988h 1 111
DW 9966h 5566 7788 5566 7788
z DW ? + 9966 9988 + 9966 9988
DW ?
EECD 1110 EECC 1110
.code (BX) (AX)
MOV AX, x
MOV BX,
BX x+2
ADD AX, y → CF=1
ADD BX, y+2 → ADC BX, y+2 BX:= BX+(y+2)+CF
MOV z, , AX
MOV z+2, BX
END SYSC3006 13
 Control Flow : JMP instructions

Four types of JUMP instructions:

Unary (unconditional) jumps : always execute
JMP target
Simple jumps: jump is taken when a specific status flag is set
Conditional JC target (Jump if CF=1)
Jumps Unsigned jumps: jumps are taken when a comparison or test of
unsigned numbers results in a specific combination of status flag
Implication : Preceded
JA target (Jump if above) by an instruction that alters
the
h appropriate
i flags
fl
Signed jumps: jumps are taken when a comparison or test of
signed quantities results in a specific combination of status flags
JG target (Jump if greater than)
SYSC3006 14
 Signed
g and Unsigned
g Conditional Instructions

• The pprocessor provides

p status flags
g to reflect results of (binary)
( y)
manipulation under both signed and unsigned interpretations
• For this reason, there are separate conditional jump instructions
for signed
g and unsigned
g
– Semantically equivalent but implementation tests the flags
appropriate to the data type.

Unsigned Signed
JA Above JG Greater
JAE Above or Equal JGE Greater or Equal
JB Below JL Less
JBE Below or Equal JLE Less or Equal
• There are also instructions for Not conditions too!
SYSC3006 15
Example : Conditional Branches
Suppose AL contains 7FH:
Unsigned Scenario Signed Scenario
CMP AL,, 80h CMP AL,80h
,
JA Bigger JG Bigger

In each scenario, is the jump taken? Why?

Programmer MUST know how binary values are to be interpreted!

(e.g. value in AX above)

SYSC3006 16
 Limitation of JJ* Instructions

• Conditional jump are restricted to 8-bit signed relative offset!

– IP := IP + (offset sign-extended to 16-bits)
– Can’t jump very far! – 128 +127 bytes
• Example:
p JL Less maximum possible
…. distance = 127 bytes
Less: MOV . . .
• One possible workaround if distance is greater than 127 bytes
(but not the only one!):
JNL Continue JMP can have 16-bit relative offset
JMP LessL distance can now be > 127
Continue: ….
Less: MOV . . .

SYSC3006 17
Example Write a code fragment showing how you would implement the
following pseudocode
boolean done = FALSE;
while ( ! done )
{ …. }
Solution: TRUE equ 1
FALSE equ 0
.code
MOV AL
AL, FALSE ; AL= register variable done
notDone: CMP AL, TRUE
JE amDone
; ....; Somewhere : MOV AL, TRUE
JMP notDone
amDone: …

SYSC3006 18
 LOOP Instruction
• U
Useful
f l when
h you have
h an action
ti repeated
t d a given
i number
b off
times
• C++ analogy
for (int i=max; i > 0; i--)

MOV CX, max

DoLoop: . . .
SUB CX, 1
JNZ DoLoop
Functionally equivalent Different performance & code size

MOV CX, max

DoLoop: . . . • LOOP automatically
decrements CX
p
LOOP DoLoop • Only works with CX

SYSC3006 19
 Data Manipulation : DIV
Unsigned Integer Division
• Syntax : DIV src
• Semantics : Performs an integer division : Accumulator / src
– The size of divisor (8-bit or 16-bit) is determined by size of
src
– src may be specified using register, direct or indirect mode
but not immediate mode 16-bit dividend
bit divisor
88-bit
• 8-bit division : DIV src where src = 8-bit operand
– Semantics divide src into 16-bit value in AX
Two
wo 88-bit
bt Integer result
results – AL := AX ÷ src (
(unsigned
i d di
divide)
id )
AH := AX mod src ( unsigned modulus) Integer remainder
– The flags are undefined after DIV (values may have
changed,
h d no meaning)
i )
SYSC3006 20
 Data Manipulation : DIV 32-bit dividend
16-bit divisor

• 16-bit division : DIV src where src = 16-bit operand

– Semantics divide src into 32-bit value obtained by
concatenating
co c e g DX andd AX (written
(w e DX:AX) : )
Two 16-
Integer result
bit results
AX := DX:AX ÷ src (unsigned divide) Integer remainder
DX :=: DX:AX mod src ( unsigned modulus)
– The flags are undefined after DIV (values may have changed,
no meaning)
Q i : In
Question I either
i h case, what
h if the
h result
l is
i too big
bi to fit
fi in
i
destination?
• eg : AX ÷ 1 ?? AL = ??
• overflow trap – more later!
SYSC3006 21
 Data Manipulation : Logical Operations
Syntax : LOGICAL_MNEUMONIC dest, src
Semantics : dest = dest LOGICAL_MNEUMONIC src

Example : AND AL, 80h

Example : .data
control DB ? AND OR XOR
.code
code 0 0 0 0 0
OR control, BH 0 1 0 1 1
(where BH=02h) 1 0 0 1 1
1 1 1 1 0
Example : XOR AX, AX
XOR AX
AX, 0FFh O e ti bit by
Operation b bit!
SYSC3006 22
 Data Manipulation : Shift

• Versions for : Left/Right and Arithmetic/Logical

Logical Shift Right
0 b7 ----------------- b0 C

SHR AL, 1

Arithmetic Shift Right

g

MOV CL, 2 b7 ----------------- b0 C

SAR AL, CL

Logical or Arithmetic Shift Left

C b7 ----------------- b0 0
SHL AL, 1
AL
SAL AL, 1
SYSC3006 23
 Data Manipulation : Rotate

• Versions for : Left/Right and with/out carry

Rotate-Carry-Left
C f

RCL AL, 1
b7 ----------------- b0 C
Rotate Left

MOV CL, 4 b7 ----------------- b0 C

ROL AL, CL

SYSC3006 24
Examplep Write a code fragment
g to test whether a variable is
divisible by 4, leaving the boolean result in AX.
Solution: A number divisible by 4 would have the least significant
two bits equal
q 0s.

FALSE equ 0
TRUE equ 1
.data
variable dw 1922h
.code
code
MOV AX, variable
Alterative :
AND AX, 03h
JZ yes TEST variable,
i bl 03h
MOV AX, FALSE
JMP continue
yes: MOV AX TRUE
AX,
continue:
SYSC3006 25
…
Example Suppose a robot has four motors, each of which can be
off,
ff on iin forward
f d direction
di ti or on in i reverse direction.
di ti The
Th status
t t
of these motors are written by the robot into a status word, say
called “motors” in the following bitmap formation.
7 6 5 4 3 2 1 0
Motor1 Motor2 Motor3 Motor4

where
h the h two bits
bi for
f eachh motor are set according
di
01 forward
10 reverse
11 off
Write a code fragment that waits until motor1 is off before
continuing on.

SYSC3006 26
Solution: .data
data
motors db ?
.code
waiting: MOV AL,
AL motors
AND AL, 0C0h
CMP AL, 0C0h
JNZ waiting
…

SYSC3006 27