This preview shows page 1. Sign up to view the full content.
Unformatted text preview: MIPS arithmetic
Today we’ll review all the important ideas of arithmetic from CS231.
— Unsigned and signed number representations.
— Addition and subtraction with two’s complement numbers.
— Overflow detection.
These issues are important in understanding MIPS arithmetic instructions.
Finally, we review the construction of an ALU that will appear in our CPU
designs in the next few weeks. February 17, 2003 ©20012003 Howard Huang 1 Unsigned numbers
We can store unsigned numbers as their binary equivalents.
Bit position i has a decimal weight 2i, so the decimal value v of an nbit
unsigned binary number an–1an–2...a1a0 can be calculated as below.
n −1 v = ∑ 2i ⋅ ai
i =0 This is just the sum of each digit times the weight of its position.
1 0 1 1 0 12 = (25•1) + (24•0) + (23•1) + (22•1) + (21•0) + (20•1) = 4510
The smallest and largest possible numbers are 0 and 2n–1.
In MIPS, the largest unsigned number is 232–1, or about 4.3 billion. February 17, 2003 MIPS arithmetic 2 Hexadecimal notation
Hexadecimal is frequently used as a shorthand for binary
numbers, because one hex digit corresponds to four bits.
Converting between binary and hex is easy with a table.
B E E F16 = 1011 1110 1110 11112
In SPIM and many highlevel programming languages, the
prefix 0x denotes a hexadecimal constant, as in 0xBEEF. M oo . February 17, 2003 MIPS arithmetic Binary Hex 0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111 0
1
2
3
4
5
6
7
8
9
A
B
C
D
E
F 3 Working with unsigned numbers
Addition can be done just like in decimal.
1 1 1 0 1 1 0 1 45 0
1 1 1
+ 1
1 0 1 1 1 + 23 0 0 0 1 0 0 68 Multiplication and integer division by powers of 2 can be done using left
and right “logical” shifts.
1 0 1 1 0 1 × 10 = 1 0 1 1 0 1 0
1 0 1 1 0 1 ⁄ 10 =
010110 February 17, 2003 MIPS arithmetic 45 × 2 = 90
45 ⁄ 2 = 22 4 Logical shifts in MIPS
MIPS has sll (shift left logical) and srl (shift right logical) instructions.
— A constant specifies the number of bits to shift, from 0 to 31.
— 0s are shifted into the right or left sides, respectively.
For example, assume that $t0 contains 0xFEEDBEEF.
sll $t1, $t0, 4
srl $t2, $t0, 12 # $t1 contains 0xEEDBEEF0
# $t2 contains 0x000FEEDB Shifts are actually Rtype instructions, not Itype!
op rs rt rd shamt func 6 bits 5 bits 5 bits 5 bits 5 bits 6 bits The constant is stored in the 5bit “shamt” field that we hadn’t seen up
until now. February 17, 2003 MIPS arithmetic 5 Unsigned overflow
One recurring issue in computer arithmetic is dealing with finite amounts
of storage, such as 32bit MIPS registers.
Overflow occurs when the result of an operation is too large to be stored.
There are many examples of unsigned nbit overflows.
— When there is a carry out of position n–1 in an addition.
— When an–1 is 1 in a multiplication by two.
The 6bit addition and multiplication operations on page 4 both result in
overflow, since the correct answers require 7 bits. February 17, 2003 MIPS arithmetic 6 Signed two’scomplement numbers
Signed numbers are represented in two’s complement format.
The most significant bit an–1 of each number is a sign bit.
— 0 indicates a positive number.
— 1 indicates a negative number.
The range of nbit signed numbers is from –2n–1 to +2n–1–1
— For 32bit values, the range is roughly ±2.15 billion.
— The ranges are not exactly even since there are 2n–1 negative numbers,
but just 2n–1–1 positive numbers. February 17, 2003 MIPS arithmetic 7 Two’scomplement values
The magnitude of a negative number is represented in a funny way that
makes x + –x = 2n for all numbers x.
The decimal value v of a two’scomplement number an–1an–2...a1a0 is: ( v = − 2n−1 ⋅ an−1
This term accounts
for the sign. ) n−2 i + ∑ 2 ⋅ ai i =0
The magnitude is
computed like before. Here are two examples with n = 6.
010111 = (–25•0) + (24•1) + (23•0) + (22•1) + (21•1) + (201) = 23
101101 = (–25•1) + (24•0) + (23•1) + (22•1) + (21•0) + (20•1) = –19 February 17, 2003 MIPS arithmetic 8 Negating a two’s complement number
There are three main ways to negate two’s complement numbers. As an
example, let’s consider the sixbit value 101101 (–19).
1. Complement all the bits in the number and then add 1.
— Complementing the bits in 101101 yields 010010.
— Adding 1 results in 010011 (+19).
2. Complement the bits to the left of the rightmost 1.
— The rightmost 1 in 101101 is in position 0.
— Complementing the bits to its left gives 010011 (+19).
3. Subtract the number from 2n.
— 26 is 1000000.
— Then, 1000000 – 101101 = 010011 (+19). February 17, 2003 MIPS arithmetic 9 Two’scomplement numbers with n=4
Decimal 2C 2C Decimal –8
–7
–6
–5
–4
–3
–2
–1 1000
1001
1010
1011
1100
1101
1110
1111
0000
0001
0010
0011
0100
0101
0110
0111 0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111 0
1
2
3
4
5
6
7
–8
–7
–6
–5
–4
–3
–2
–1 0
1
2
3
4
5
6
7
February 17, 2003 MIPS arithmetic 10 Working with signed numbers
Addition with two’s complement is the same as with unsigned numbers.
— The sign bits are included in the addition.
— The carry out is ignored.
1 1 1 0 1 1 0 1 0
1 1 1
+ 1
1 0 1 1 1 0 0 0 1 0 0 –19 + 23
4 A subtraction operation A – B is treated as an addition of A + (–B). February 17, 2003 MIPS arithmetic 11 Signed overflow
It’s also possible for two’scomplement operations to overflow.
Overflow occurs only when we add two numbers of the same sign and get
a different sign for the result.
— Adding two positive numbers should result in a positive number.
— Adding two negative numbers should yield a negative result.
1 February 17, 2003 1 0 0 1 1 +19 1 0 1 1 1 + +23 1 0 1 0 1 0 – 22 1 0 0 1 1 0 1 1 0 1 – 19 1
1 1 0
+ 1 0
0 1 0
+ 0 0 1 0 0 1 + – 23 0 1 0 1 1 0 + 22 MIPS arithmetic 12 Ariane 5
In 1996, the European Space Agency’s Ariane 5 rocket was launched for
the first time... and it exploded 40 seconds after liftoff.
It turns out the Ariane 5 used software designed for the older Ariane 4.
— The Ariane 4 stored its horizontal velocity as a 16bit signed integer.
— But the Ariane 5 reaches a much higher velocity, which caused an
overflow in the 16bit quantity.
The overflow error was never caught, so incorrect instructions were sent
to the rocket boosters and main engine. February 17, 2003 MIPS arithmetic 13 Sign extension
We often work with signed numbers of different lengths.
— Instructions like lw $t0, –4($sp) add 16bit and 32bit values together.
— slti $t0, $t0, 256 compares a 16bit constant to a 32bit number.
— The lb instruction copies an 8bit value into a 32bit register.
You can sign extend a two’s complement number by copying the sign bit.
For instance, we can sign extend 6bit numbers to 8 bits.
(+23) 010111 00010111 (+23) (–19) 101101 11101101 (–19) If you add 0s instead of sign extending, you may accidentally change the
sign, and hence the value, of the result.
(–19) February 17, 2003 101101 00101101 (+45) MIPS arithmetic 14 Interpreting bit patterns
One of the most important things to remember is that bit patterns have
different meanings under different representations!
— As a sixbit unsigned number, 101101 denotes 45 in decimal.
— But as a two’s complement number, 101101 denotes –19.
The example C program below prints the same data (0xFFFFFFFF) twice,
but under different interpretations. main()
{
int x = 0xFFFFFFFF;
printf("x = %d\n", x);
printf("x = %u\n", x);
} February 17, 2003 // CSIL Sun machines
// 32bit integers
// Signed; prints 1
// Unsigned; prints 4294967295 MIPS arithmetic 15 Signed and unsigned comparisons
Specifying the interpretation of binary numbers is especially important in
untyped assembly language programming.
For example, how does 111111 compare to 000000?
— As an unsigned number, 111111 = 63, which is greater than 0.
— As a two’s complement number, 111111 = –1, which is less than 0.
MIPS includes two versions of the comparison instructions.
— The slt and slti instructions that we saw do signed comparisons.
— The instructions sltu and sltiu perform unsigned comparisons.
main()
{
unsigned int u = 0xFFFFFFFF;
int s = 0xFFFFFFFF;
printf("%u is %s than 0\n", u, (u < 0 ? "less" : "greater"));
printf("%d is %s than 0\n", s, (s < 0 ? "less" : "greater"));
} February 17, 2003 MIPS arithmetic 16 Signed and unsigned addition
MIPS provides two versions of the main arithmetic instructions.
— The add, addi and sub instructions will raise an exception if they
cause an overflow.
— But addu, addiu, and subu do not raise exceptions on overflow
Be careful! Both addi and addiu sign extend their constant field, even
though addiu is considered an “unsigned” operation.
In C, overflow exceptions may or may not be raised, depending on the
underlying hardware. main()
{
int x = 0x7FFFFFFF;
printf("x = %d\n", x);
x++;
printf("x = %d\n", x);
} February 17, 2003 // CSIL Sun machines
// Largest 32bit number
// Prints 2147483647
// Prints 2147483648 MIPS arithmetic 17 When to use unsigned numbers
Memory addresses should be treated as unsigned numbers.
— The fourth element of an array that starts at 0x7FFFFFF0 is at address
0x80000000. This address computation should not overflow!
— In fact, stack pushes and pops should be performed using the unsigned
add and subtract instructions like addiu, and not addi.
Nonnumeric data should also be handled using unsigned operations.
— We can represent up to 32 Boolean values with one MIPS word.
— Similarly, several fields of data can be packed into one word, such as
the encoding of MIPS instructions themselves!
The and and or instructions do bitwise manipulations on registers. The
immediate variants, andi and ori, do not sign extend their constants. February 17, 2003 MIPS arithmetic 18 MIPS arithmetic instruction summary
Addition and subtraction
— add, addi, and sub raise exceptions on overflow.
— addu, addiu, and subu do not raise exceptions on overflow.
— addi and addiu both sign extend their immediate fields.
Comparisons
— slt and slti are for signed comparisons.
— sltu and sltiu do unsigned comparisons.
— slti and sltiu both sign extend their immediate fields.
Data transfers
— lb sign extends the byte that is loaded into a register.
— lbu does not sign extend the byte.
Shifting
— sll and srl are used for logical shifts of up to 31 bits.
Bitwise operators
— andi and ori do not sign extend their immediate field.
February 17, 2003 MIPS arithmetic 19 Hardware for singlebit operations
We can use a full adder to add data inputs a, b and a carry in cin. This
produces a onebit result and a carry out cout.
a b
+ cout cin result
It’s also easy to do one bit and and or operations.
ab ab
February 17, 2003 ab a+b MIPS arithmetic 20 A onebit ALU
A simple onebit ALU can support all three
of these functions.
A twobit input called operation selects the
desired function using a 3to1 multiplexer. operation
0
1
2 a result
a and b
a or b
a + b + carry in b carry in
carry out + 2 1 0 operation result
February 17, 2003 MIPS arithmetic 21 An nbit ALU
This onebit ALU can be replicated to produce an nbit ALU.
— The carry out from stage i connects to the carry in of stage i+1.
— The operation input is shared by all of the onebit circuits.
operation
a3 b3 a2 b2 a1 b1 a0 b0 ALU ALU ALU ALU result3 carry
out result2 result1 result0 February 17, 2003 MIPS arithmetic carry
in 22 A whole MIPS ALU
We can do the subtraction of a – b by complementing the b input, setting
carry in to 1, and performing an addition.
The ALU also has a slt function, which sets result to 1 or 0 depending on
whether or not a is less than b. This can be determined via subtraction.
Finally, outputs can be generated to signal overflow or a result of zero.
ALU
operation
ALU
operation Result 000
001
010
110
111 a and b
a or b
a+b
a–b
a<b 3 a 32
32 b 32 Zero
Result
Overflow Carry Out
February 17, 2003 MIPS arithmetic 23 MIPS ALU design
ALUs are a good example of modular hardware design.
— 32 full adders can be connected together to form a 32bit adder.
— Bitwise operations can also be handled one bit at a time.
— Adders can also be used to perform subtraction.
Shift operations are usually handled outside the ALU by a combinational
“barrel shifter” circuit, which can shift an arbitrary number of positions
in constant time. February 17, 2003 MIPS arithmetic 24 Summary
Signed numbers are represented using the two’s complement format.
— A sign bit distinguishes between positive and negative numbers.
— Numbers are negated by complementing their bits and adding 1.
— This makes subtraction hardware easy to build.
Signed and unsigned numbers have many important differences.
— Some operations require that we sign extend the operands.
— Overflow detection differs for signed and unsigned operations.
The MIPS instruction set includes both signed and unsigned operations,
which affect how constant operands and overflows are handled. February 17, 2003 MIPS arithmetic 25 ...
View
Full
Document
This note was uploaded on 01/14/2012 for the course CS 251 taught by Professor Howardhuang during the Fall '09 term at Waterloo.
 Fall '09
 howardhuang

Click to edit the document details