Prof.

Hakim Weatherspoon
CS 3410, Spring 2015
Computer Science
Cornell University
See: P&H Chapter 2.4, 3.2, B.2, B.5, B.6
 inst
memory register alu
file

+4 +4
addr
=?
PC din dout
offset control cmp
memory
new target
imm
pc extend

A Single cycle processor

Binary Operations
• Number representations
• One-bit and four-bit adders
• Negative numbers and two’s compliment
• Addition (two’s compliment)
• Subtraction (two’s compliment)
Recall: Binary
• Two symbols (base 2): true and false; 1 and 0
• Basis of Logic Circuits and all digital computers

So, how do we represent numbers in Binary (base 2)?

Recall: Binary
• Two symbols (base 2): true and false; 1 and 0
• Basis of Logic Circuits and all digital computers

So, how do we represent numbers in Binary (base 2)?

• We know represent numbers in Decimal (base 10).
– E.g. 6 3 7
102 101 100

• Can just as easily use other bases

– Base 2 — Binary 219 208 207 1 11
26 25 24
1101
23 22 21 20
– Base 8 — Octal 0o 1 1 7 5
– Base 16 — Hexadecimal83 82 81 80 0x 2 7 d
162161160
Recall: Binary
• Two symbols (base 2): true and false; 1 and 0
• Basis of Logic Circuits and all digital computers

So, how do we represent numbers in Binary (base 2)?

• We know represent numbers in Decimal (base 10).
– E.g. 6 3 7 6∙102 + 3∙101 + 7∙100 = 637
102 101 100

• Can just as easily use other bases

– Base 2 — Binary 1∙29+1∙26+1∙25+1∙24+1∙23+1∙22+1∙20 = 637
– Base 8 — Octal 1∙83 + 1∙82 + 7∙81 + 5∙80 = 637
2∙162 + 7∙161 + d∙160 = 637
– Base 16 — Hexadecimal 2∙162 + 7∙161 + 13∙160 = 637
How do we count in different bases?
• Dec (base 10) Bin (base 2) Oct (base 8) Hex (base 16)
0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 a
11 1011 13 b
12 1100 14 c
13 1101 15 d
14 1110 16 e
15 1111 17 f
16 1 0000 20 10
17 1 0001 21 11
18 1 0010 22 12
. . . .
. . . .

99
100
How to convert a number between different bases?
Base conversion via repetitive division
• Divide by base, write remainder, move left with quotient
lsb (least significant bit)
• 637 ÷ 8 = 79 remainder 5
• 79 ÷ 8 = 9 remainder 7
• 9 ÷ 8 = 1 remainder 1
• 1 ÷ 8 = 0 remainder 1 msb (most significant bit)

637 = 0omsb1175lsb
Convert a base 10 number to a base 2 number
Base conversion via repetitive division
• Divide by base, write remainder, move left with quotient
lsb (least significant bit)
• 637 ÷ 2 = 318 remainder 1
• 318 ÷ 2 = 159 remainder 0
• 159 ÷ 2 = 79 remainder 1
• 79 ÷ 2 = 39 remainder 1
• 39 ÷ 2 = 19 remainder 1
• 19 ÷ 2 = 9 remainder 1
• 9÷2=4 remainder 1
• 4÷2=2 remainder 0
• 2÷2=1 remainder 0
• 1÷2=0 remainder 1 msb (most significant bit)
637 = 10 0111 1101 (can also be written as 0b10 0111 1101)
msb lsb
Convert a base 10 number to a base 16 number
Base conversion via repetitive division
• Divide by base, write remainder, move left with quotient
lsb
• 637 ÷ 16 = 39 remainder 13
• 39 ÷ 16 = 2 remainder 7
• 2 ÷ 16 = 0 remainder 2 dec = hex = bin
msb 10 = 0xa = 1010
11 = 0xb = 1011
637 = 0x 2 7 13 = 0x ?2 7 d 12
13
=
=
0xc
0xd
= 1100
= 1101
Thus, 637 = 0x27d 14 = 0xe = 1110
15 = 0xf = 1111
Convert a base 2 number to base 8 (oct) or 16 (hex)
Binary to Hexadecimal
• Convert each nibble (group of four bits) from binary to hex
• A nibble (four bits) ranges in value from 0…15, which is one hex digit
– Range: 0000…1111 (binary) => 0x0 …0xF (hex) => 0…15 (decimal)
• E.g. 0b10 0111 1101
– 0b10 = 0x2
– 0b0111 = 0x7
– 0b1101 = 0xd
– Thus, 637 = 0x27d = 0b10 0111 1101

Binary to Octal
• Convert each group of three bits from binary to oct
• Three bits range in value from 0…7, which is one octal digit
– Range: 0000…1111 (binary) => 0x0 …0xF (hex) => 0…15 (decimal)
• E.g. 0b1 001 111 101
– 0b1 = 0x1
– 0b001 = 0x1
– 0b111 = 0x7
– 0b101 = 0x5
– Thus, 637 = 0o1175 = 0b10 0111 1101
We can represent any number in any base
• Base 10 – Decimal
637 6∙102 + 3∙101 + 7∙100 = 637
102 101 100

• Base 2 — Binary
10 0111 1101 1∙29+1∙26+1∙25+1∙24+1∙23+1∙22+1∙20 = 637
29 28 27 26 25 24 23 22 21 20

• Base 8 — Octal
0o 1 1 7 5 1∙83 + 1∙82 + 7∙81 + 5∙80 = 637
83 82 81 80

• Base 16 — Hexadecimal
0x 2 7 d 2∙162 + 7∙161 + d∙160 = 637
162161160 2∙162 + 7∙161 + 13∙160 = 637
Digital computers are implemented via logic circuits and thus
represent all numbers in binary (base 2).

We (humans) often write numbers as decimal and hexadecimal

for convenience, so need to be able to convert to binary and
back (to understand what computer is doing!).
Binary Arithmetic: Add and Subtract two binary numbers
 How do we do arithmetic in binary?

1 Addition works the same way

183 regardless of base
+ 254 • Add the digits in each position
437
Carry-in
• Propagate the carry
Carry-out
111
001110 Unsigned binary addition is pretty easy
+ 011100 • Combine two bits at a time
• Along with a carry
101010
How do we do arithmetic in binary?

1 Addition works the same way

183 regardless of base
+ 254 • Add the digits in each position
437 • Propagate the carry

111
001110 Unsigned binary addition is pretty easy
+ 011100 • Combine two bits at a time
• Along with a carry
101010
Binary addition requires
• Add of two bits PLUS carry-in
• Also, carry-out if necessary
 A B Half Adder
• Adds two 1-bit numbers
Cout • Computes 1-bit result and
1-bit carry
• No carry-in
S

A B Cout S
0 0
0 1
1 0
1 1
 A B Full Adder
• Adds three 1-bit numbers
Cout Cin • Computes 1-bit result and 1-bit carry
• Can be cascaded
S
Activity: Truth Table and Sum-of-Product.
A B Cin Cout S
0 0 0 Logic minimization via Karnaugh Maps and
0 0 1 algebraic minimization.
0 1 0 Draw Logic Circuits
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
 A[4] B[4] 4-Bit Full Adder
• Adds two 4-bit numbers and carry in
Cout Cin • Computes 4-bit result and carry out
• Can be cascaded
S[4]
 A3 B 3 A2 B 2 A1 B 1 A0 B 0

Cout Cin

S3 S2 S1 S0

• Adds two 4-bit numbers, along with carry-in

• Computes 4-bit result and carry out

• Carry-out = overflow indicates result does not

fit in 4 bits
Digital computers are implemented via logic circuits and
thus represent all numbers in binary (base 2).

We (humans) often write numbers as decimal and

hexadecimal for convenience, so need to be able to convert
to binary and back (to understand what computer is
doing!).

Adding two 1-bit numbers generalizes to adding two

numbers of any size since 1-bit full adders can be cascaded.
How do we subtract two binary numbers?
Equivalent to adding with a negative number

How do we represent negative numbers?

First Attempt: Sign/Magnitude Representation
• 1 bit for sign (0=positive, 1=negative)
• N-1 bits for magnitude
0111 = 7
Problem? 1111 = -7
• Two zero’s: +0 different than -0
• Complicated circuits

0000 = +0
1000 = -0
IBM 7090
Second Attempt: One’s complement
• Leading 0’s for positive and 1’s for negative
• Negative numbers: complement the positive number
0111 = 7
Problem? 1000 = -7
• Two zero’s still: +0 different than -0
• -1 if offset from two’s complement
• Complicated circuits
– Carry is difficult
0000 = +0
1111 = -0
PDP 1
What is used: Two’s Complement Representation

Nonnegative numbers are represented as usual

• 0 = 0000, 1 = 0001, 3 = 0011, 7 = 0111

Leading 1’s for negative numbers

To negate any number:
• complement all the bits (i.e. flip all the bits)
• then add 1
• -1: 1 ⇒ 0001 ⇒ 1110 ⇒ 1111
• -3: 3 ⇒ 0011 ⇒ 1100 ⇒ 1101
• -7: 7 ⇒ 0111 ⇒ 1000 ⇒ 1001
• -8: 8 ⇒ 1000 ⇒ 0111 ⇒ 1000
• -0: 0 ⇒ 0000 ⇒ 1111 ⇒ 0000 (this is good, -0 = +0)
Non-negatives Negatives
(as usual): (two’s complement: flip then add 1):
+0 = 0000 0� = 1111 -0 = 0000
+1 = 0001 1� = 1110 -1 = 1111
+2 = 0010 2� = 1101 -2 = 1110
+3 = 0011 3� = 1100 -3 = 1101
+4 = 0100 4� = 1011 -4 = 1100
+5 = 0101 5� = 1010 -5 = 1011
+6 = 0110 6� = 1001 -6 = 1010
+7 = 0111 7� = 1000 -7 = 1001
+8 = 1000 8� = 0111 -8 = 1000
Non-negatives Negatives
(as usual): (two’s complement: flip then add 1):
+0 = 0000 0� = 1111 -0 = 0000
+1 = 0001 1� = 1110 -1 = 1111
+2 = 0010 2� = 1101 -2 = 1110
+3 = 0011 3� = 1100 -3 = 1101
+4 = 0100 4� = 1011 -4 = 1100
+5 = 0101 5� = 1010 -5 = 1011
+6 = 0110 6� = 1001 -6 = 1010
+7 = 0111 7� = 1000 -7 = 1001
+8 = 1000 8� = 0111 -8 = 1000
Signed two’s complement
• Negative numbers have leading 1’s
• zero is unique: +0 = - 0
• wraps from largest positive to largest negative
N bits can be used to represent
• unsigned: range 0…2N-1
– eg: 8 bits ⇒ 0…255
• signed (two’s complement): -(2N-1)…(2N-1 - 1)
– E.g.: 8 bits ⇒ (1000 000) … (0111 1111)
– -128 … 127
Extending to larger size
• 1111 = -1
• 1111 1111 = -1
• 0111 = 7
• 0000 0111 = 7
Truncate to smaller size
• 0000 1111 = 15
• BUT, 0000 1111 = 1111 = -1
Addition with two’s complement signed numbers
Perform addition as usual, regardless of sign
(it just works)

Examples
• 1 + -1 =
• -3 + -1 =
• -7 + 3 =
• 7 + (-3) =
• What is wrong with the following additions?
–7+1 -7 + -3 -7 + -1
Why create a new circuit?
Just use addition using two’s complement math
• How?
Two’s Complement Subtraction
• Subtraction is simply addition,
where one of the operands has been negated
– Negation is done by inverting all bits and adding one
� + 1)
A – B = A + (-B) = A + (B
B3 B2 B1 B0
A3 A2 A1 A0

Cout

S3 S2 S1 S0
Two’s Complement Subtraction
• Subtraction is simply addition,
where one of the operands has been negated
– Negation is done by inverting all bits and adding one
� + 1)
A – B = A + (-B) = A + (B
B3 B2 B1 B0
A3 A2 A1 A0

Cout 1

S3 S2 S1 S0
Q: How do we detect and handle overflows?
Q: What if (-B) overflows?
Digital computers are implemented via logic circuits and thus
represent all numbers in binary (base 2).
We (humans) often write numbers as decimal and hexadecimal
for convenience, so need to be able to convert to binary and
back (to understand what computer is doing!).

Adding two 1-bit numbers generalizes to adding two numbers

of any size since 1-bit full adders can be cascaded.

Using Two’s complement number representation simplifies

adder Logic circuit design (0 is unique, easy to negate).
Subtraction is simply adding, where one operand is negated
(two’s complement; to negate just flip the bits and add 1).
.
In general, how do we detect and handle overflow?
When can overflow occur?
• adding a negative and a positive?

• adding two positives?

• adding two negatives?

Digital computers are implemented via logic circuits and thus
represent all numbers in binary (base 2).
We (humans) often write numbers as decimal and hexadecimal for
convenience, so need to be able to convert to binary and back (to
understand what computer is doing!).

Adding two 1-bit numbers generalizes to adding two numbers of

any size since 1-bit full adders can be cascaded.

Using Two’s complement number representation simplifies adder

Logic circuit design (0 is unique, easy to negate). Subtraction is
simply adding, where one operand is negated (two’s complement;
to negate just flip the bits and add 1).

Overflow if sign of operands A and B != sign of result S.

Can detect overflow by testing Cin != Cout of the most significant bit
(msb), which only occurs when previous statement is true.
Make sure you are
• Registered for class, can access CMS
• Have a Section you can go to.
• Lab Sections are required.
• “Make up” lab sections only 8:40am Wed, Thur, or Fri
• Bring laptop to Labs
• Have project partner in same Lab Section, if possible

HW1 will be out soon out

• Do problem with lecture
• Work alone
• But, use your resources
₋ Lab Section, Piazza.com, Office Hours, Homework Help Session,
₋ Class notes, book, Sections, CSUGLab
Check online syllabus/schedule
• http://www.cs.cornell.edu/Courses/CS3410/2015sp/schedule.html
• Slides and Reading for lectures
• Office Hours
• Pictures of all TAs
• Homework and Programming Assignments
• Dates to keep in Mind
• Prelims: Tue Mar 3rd and Thur April 30th
• Lab 1: Due Fri Feb 13th before Winter break
• Proj2: Due Thur Mar 26th before Spring break
• Final Project: Due when final would be (not known until Feb 14t
Schedule is subject to change
We can now implement combinational logic circuits
• Design each block
– Binary encoded numbers for compactness
• Decompose large circuit into manageable blocks
– 1-bit Half Adders, 1-bit Full Adders,
n-bit Adders via cascaded 1-bit Full Adders, ...
• Can implement circuits using NAND or NOR gates
• Can implement gates using use PMOS and NMOS-
transistors
• And can add and subtract numbers (in two’s
compliment)!
• Next time, state and finite state machines…