04 Arithmetic

Download as pdf or txt
Download as pdf or txt
You are on page 1of 29

3D1 / Microprocessor Systems I

Binary Arithmetic Binary Arithmetic

 Addition

0 0 1 1 0 6
0 1 0 1 1  11 
1 0 0 0 1 17

1 0 1 1 0 22
0 1 0 1 1  11 
1 0 0 0 0 1 33

1
3D1 / Microprocessor Systems I
Carry Binary Arithmetic

 What happens if we run out of digits?


• Adding two numbers each stored in 1 byte (8 bits) may
produce a 9-bit result
8 bits

1 0 0 1 1 1 0 0 156
1 0 1 0 0 1 1 1  167 
1 0 1 0 0 0 0 1 1 323

• Added 15610 + 16710 and expected to get 32310


• 8-bit result was 010000112 or 6710
• Largest number we can represent in 8-bits is 255
• The issi g or left-o er is alled a carry (or carry-out)
2
3D1 / Microprocessor Systems I
Condition Code Flags Binary Arithmetic

Current Program Status Register

N Z V C Reserved Control Bits


31 30 29 28 27 8 7 0

Condition Code
Flags
 Some instructions can optionally update the Condition
Code Flags to provide information about the result of
the execution of the instruction
• e.g. whether the result of an addition was zero, or negative or
whether a carry occurred
N – Negative Z – Zero
V – oVerflow C – Carry
3
3D1 / Microprocessor Systems I
Condition Code Flags Binary Arithmetic

 The Condition Code Flags (N, Z, V, C) can be optionally


updated to reflect the result of an instruction
 S-bit in a machine code instruction is used to tell the
processor whether the Condition Code Flags should be
updated, based on the result
• e.g. ADD instruction
• Condition Code Flags only updated if S-bit (bit 20) is 1

11100000100 S Rn Rd 00000000 Rm
31 21 20 19 16 15 12 11 4 3 0

 In assembly language, we cause the Condition Code


Flags to e updated y appe di g “ to the i stru tio
mnemonic (e.g. ADDS, SUBS, MOVS)
4
Program 4.1 – Carry
3D1 / Microprocessor Systems I
Binary Arithmetic

start
LDR r0, =0xC0000000
LDR r1, =0x70000000
ADDS r0, r0, r1

stop B stop

 ADDS causes the Condition Code


Flags to be updated
 32-bit arithmetic
 Expected result?
 Does the result fit in 32-bits?
 Will the carry flag to be set?
 Examine flags using µVision IDE

5
3D1 / Microprocessor Systems I
Negative Numbers Binary Arithmetic

 The following binary value is stored in memory. What


does the value represent?
• 010011012

 Interpretation!

 How can we represent signed values, and negative


values such as -1710 in particular, in memory?

 How can we tell whether any given value in memory


represents an unsigned value, a signed value, an ASCII
character, ... 6
3D1 / Microprocessor Systems I
Sign-Magnitude Binary Arithmetic

sign
magnitude
+/-
31 30 0

0 000 0000 0000 0000 0000 0000 0000 1000 +810


31 30 0

1 000 0000 0000 0000 0000 0000 0000 1000 -810


31 30 0

 Represent signed values in the range [-127 ... +127]


 Two representations of zero (+0 and -0)
 Need special way to handle signed arithmetic
 Remember: interpretation! (is it -8 or 2,147,483,656?)
7
3D1 / Microprocessor Systems I
Modulo-arithmetic Binary Arithmetic

 A 12-hour clock is an 12
11 1
example of modulo-12
arithmetic 10 2

 If we add 4 hours to 10
o’ lo k e get o’ lo k 9 3

 If we subtract 4 from 2
o’ lo k e get 8 4

o’ lo k ot - o’ lo k! 7 5
6

8
2’s Co ple e t
3D1 / Microprocessor Systems I
Binary Arithmetic

 A 4-bit number
system allows us to 1111
0000
0001
represent 16 values 0
15 1
1110 0010
 Ignoring carries from 14 2
addition gives us
1101 0011
modulo-16 arithmetic 13 3

1100 12 4 0100
 (15 + 1) mod 16 = 0
• and -1 + 1 = 0 11 5

 (14 + 2) mod 16 = 0 1011 0101

• and -2 + 2 = 0
10 6

1010 0110
 (14 + 4) mod 16 = 2
9 7
8

• and -2 +4 = 2 1001
1000
0111

9
2’s Co ple e t
3D1 / Microprocessor Systems I
Binary Arithmetic

0000
1111 0001
0
15
-1 +1
1110 0010
0
14
-2 15 1 +2
14 2
1101 0011
13
-3 +3
13 3

Remember:
1100 12
-4 12 interpretation!! 4 +4 0100

11 5
11
-5 +5
1011 0101
10 6

10
-6 9 7 +6
8
1010 -7
9 +7 0110
-8
8

1001 0111
1000
10
2’s Co ple e t
3D1 / Microprocessor Systems I
Binary Arithmetic

 What is the range of signed values that can be


represe ted ith its usi g the ’s Co ple e t
system?
 How would the values -4 and +103 be represented
using a 32- it ’s Co ple e t syste ?
 How many representations for zero are there?
 How can you tell whether a value represented using a
’s Co ple e t syste is positi e or egati e?
 How can we change the sign of a number represented
usi g a ’s Co ple e t u er syste ?

11
2’s Co ple e t Exa ples
3D1 / Microprocessor Systems I
Binary Arithmetic

 Represent 9710 usi g ’ o ple e t


• 9710 = 0110 00012
• Inverting gives 1001 11102
• Adding 1 gives 1001 11112

• I terpreted as a ’s o ple e t i teger, 2 = -9710


• Interpreted as an unsigned integer, 1001 11112 = 15910

• (159 + 97) mod 256 = 0 Remember:


interpretation!!

• Correct interpretation is the responsibility of the


progra er, ot the CPU, hi h does ot k o hether a
value 1001 11112 in R0 is -9710 or 15910
12
2’s Co ple e t Exa ples
3D1 / Microprocessor Systems I
Binary Arithmetic

 Adding 0110 00012 (+9710) and 1001 11112 (-9710)


8 bits

0 1 1 0 0 0 0 1
1 0 0 1 1 1 1 1 
1 0 0 0 0 0 0 0 0

• Ignoring the carry bit yields correct signed result of 0

 Changing sign of 1001 11112 (-9710)


• Invert bits and add 1 again!!
• Inverting gives 0110 00002
• Adding 1 gives 0110 00012 (+9710)
13
Program 4.2 – Negate Value
3D1 / Microprocessor Systems I
Binary Arithmetic

 Write an assembly language program to change the


sign of the value stored in r0
 “ig of a ’s Co ple e t alue a e ha ged y
inverting the value and adding one
start
LDR r0, =7 ; value = 7 (simple test value)
MVN r0, r0 ; value = NOT value (invert bits)
ADD r0, r0, #1 ; value = value + 1 (add 1)

stop B stop

• Use of LDR r0, =7 to load a test value (7) into r0


• MVN instruction moves a value from one register to another
register and negates (inverts) the value (note same register)
• Use of ADD with immediate constant value #1 (note syntax)
14
3D1 / Microprocessor Systems I
Subtraction Binary Arithmetic

 A–B 8 bits

0 0 1 1 0 1 1 0
0 0 1 1 0 1 0 0 
0 0 0 0 0 0 1 0

 A + (TC(B))
8 bits

0 0 1 1 0 1 1 0
1 1 0 0 1 1 0 0 
1 0 0 0 0 0 0 1 0

15
3D1 / Microprocessor Systems I
Subtraction Binary Arithmetic

 A–B 8 bits

0 0 0 0 1 0 0 0
0 1 1 1 1 1 1 1 
1 0 0 0 1 0 0 1

 A + (TC(B)) 8 bits

0 0 0 0 1 0 0 0
1 0 0 0 0 0 0 1 
1 0 0 0 1 0 0 1

 When performing a subtraction operation, if the Carry


bit is set then a borrow did not occur, otherwise ...
16
3D1 / Microprocessor Systems I
ARM Instruction Set Reference Binary Arithmetic

 Chapter 4 of the ARM Architecture Reference Manual


k o as ARMARM

17
3D1 / Microprocessor Systems I
ARM Instruction Set Reference Binary Arithmetic

 ARMARM tells us how each instruction (optionally)


effects the Condition Code Flags
 e.g. ADD

18
3D1 / Microprocessor Systems I
ARM Instruction Set Reference Binary Arithmetic

• e.g. SUBtract

19
3D1 / Microprocessor Systems I
Zero and Negative Flags Binary Arithmetic

 Zero Condition Code Flag is (optionally) set if the result


of the last instruction was zero
 Negative Condition code flag is (optionally) set if the
result of the last instruction was negative
• i.e. if the Most Significant Bit (MSB) of the result was 1
 e.g. SUBtract instruction

20
2’s Co ple e t Exa ples
3D1 / Microprocessor Systems I
Binary Arithmetic

 Add +97 and +45


8 bits

0 1 1 0 0 0 0 1
0 0 1 0 1 1 0 1 
0 1 0 0 0 1 1 1 0

 Result is 1000 11102 (14210, or -11410)


 If we were interpreting values as signed integers, we
got an incorrect result
• With 8-bits, the highest +ve integer we can represent is +127
• We added two +ve numbers and obtained a –ve result
• 1000 11102 (-11410)
• The result is outside the range of the signed number system 21
3D1 / Microprocessor Systems I
oVerflow Binary Arithmetic

 If the result of an addition or subtraction gives a result


that is outside the range of the signed number system,
then an oVerflow has occurred
 The processor sets the oVerflow Condition Code Flag
after performing an arithmetic operation to indicate
whether an overflow has occurred

Current Program Status Register

N Z V C Reserved Control Bits


31 30 29 28 27 8 7 0

Condition Code
Flags
22
3D1 / Microprocessor Systems I
Carry and oVerflow Binary Arithmetic

 The Carry and oVerflow flags are set by the processor


using a set of rules
 Re e er, the pro essor does ot k o hether
we, as programmers, are choosing to interpret stored
values as signed or unsigned values
• e.g. we could interpret the binary value 100011102 as either
14210 (unsigned) or -11410 (signed)
• e ould also i terpret it as the A“CII ode for Ä
• ...
 The C and V flags are set by the processor and it is the
responsibility of the programmer to choose
• whether to interpret C or V
• how to interpret C or V
23
3D1 / Microprocessor Systems I
oVerflow Rules Binary Arithmetic

 Addition rule (r = a + b)
V = 1 if MSB(a) = MSB(b) and
MSB(r)  MSB(a)
• i.e. oVerflow accurs for addition if the operands have the
same sign and the result has a different sign

 Subtraction rule (r = a – b)
V = 1 if MSB(a)  MSB(b) and
MSB(r)  MSB(a)
• i.e. oVerflow occurs for subtraction if the operands have
different signs and the sign of the result is different from the
sign of the first operand
24
3D1 / Microprocessor Systems I
Carry and oVerflow Examples Binary Arithmetic

8 bits

0 1 1 1 0 0 0 0
Carry =1
1 0 1 1 0 0 0 0  oVerflow = 0
1 0 0 1 0 0 0 0 0

 Signed interpretation: (+112) + (-80) = +32


 Unsigned interpretation: 112 + 176 = 288
 By examining the V flag, we know that if were
interpreting the values as signed integers, the result is
correct
 If we were interpreting the values as 8-bit unsigned
values, C = 1 tells us that the result was too large to fit
in 8-bits 25
3D1 / Microprocessor Systems I
Carry and oVerflow Examples Binary Arithmetic

8 bits

1 0 1 1 0 0 0 0
Carry =1
1 0 1 1 0 0 0 0  oVerflow = 1
1 0 1 1 0 0 0 0 0

 Signed: (-80) + (-80) = -160


 Unsigned: 176 + 176 = 352
 By examining the V flag (V = 1), we know that if were
interpreting the values as signed integers, the result is
outside the range of the signed number system
 If we were interpreting the values as 8-bit unsigned
values, C = 1 tells us that the result was too large to fit
in 8-bits 26
3D1 / Microprocessor Systems I
Condiion Code Flags - Recap Binary Arithmeic

N Z VC Reserved Control Bits


31 30 29 28 27 8 7 0

 Many instrucions can opionally cause the processor to


update the Condiion Code Flags (N, Z, V, and C) to
relect certain properies of the result of an operaion
• Append “S” to instrucion in assembly language (e.g. ADDS)
• Set S-bit in machine code instrucion
 N lag set to 1 if result is negaive (if MSB is 1)
 Z lag is set to 1 if result zero (all bits are 0)
 C lag set if carry occurs (addiion) or borrow does not
occur (subtracion)
 V lag set if overlow occurs for addiion or subtracion 27
3D1 / Microprocessor Systems I
Example: 64-bit Addition Binary Arithmetic

 64-bit addition on a 32-bit processor


Most-Significant (Upper) 32 Bits Least-Significant (Lower) 32 Bits

0 0 0 0 0 E 4 4 3 2 A 8 4 F E 6
0 0 0 0 0 0 0 0 F 4 E 0 0 3 2 2 
0 0 0 0 0 E 4 5 2 7 8 8 5 3 0 8

• Split operation into two 32-bit operations


• Add lower 32 bits, followed by upper 32 bits
• A y arry-out fro the additio of the lo er its ust
e arried-i to the additio of the upper its
0 0 0 0 0 E 4 4
0 0 0 0 0 0 0 0 3 2 A 8 4 F E 6
1  F 4 E 0 0 3 2 2 
E 4 5 1 2 7 8 8 5 3 0 8 28
Program 4.3 – 64-bit Addition
3D1 / Microprocessor Systems I
Binary Arithmetic

 Use ADDS instruction to add lower 32 bits, causing the


processor to set the Carry flag if a carry-out occurs
 Use ADC instruction to add upper 32 bits, plus 1 if the
Carry flag was set (by the preceding ADDS instruction)
start

; Set some test values for A and B


LDR r2, =0x00000E44 ; Aupr
LDR r3, =0x32A84FE6 ; Alwr
LDR r4, =0x00000000 ; Bupr
LDR r5, =0xF4E00322 ; Blwr

; Add A and B
ADDS r0, r3, r5 ; Rlwr = Alwr + Blwr, update Cout
ADC r1, r2, r4 ; Rupr = Aupr + Blwr + Cout

stop B stop

 Same technique can be extended to larger values


29

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy