CS4100: 計算機結構
Instruction Set Architecture
國立清華大學資訊工程學系
一零零學年度第二學期
Outline












Instruction set architecture (Sec 2.1)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-1
Computer Architecture
What Is Computer Architecture?
Computer Architecture =
Instruction Set Architecture
+ Machine Organization

“... the attributes of a [computing] system as
seen by the [____________
assembly language]
programmer, i.e. the conceptual structure
and functional behavior …”
What are specified?
Instruction Set-2
Computer Architecture
Recall in C Language

Operators: +, -, *, /, % (mod), ...


Operands:



7/4==1, 7%4==3
Variables: lower, upper, fahr, celsius
Constants: 0, 1000, -17, 15.4
Assignment statement:
variable = expression

Expressions consist of operators operating on
operands, e.g.,
celsius = 5*(fahr-32)/9;
a = b+c+d-e;
Instruction Set-3
Computer Architecture
When Translating to Assembly ...
a = b + 5;
load
load
add
store
$r1, M[b]
$r2, 5
$r3, $r1, $r2
$r3, M[a]
Statement
Constant
Operands
Memory
Register
Operator (op code)
Instruction Set-4
Computer Architecture
Components of an ISA

Organization of programmable storage




Data types and data structures



registers
memory: flat, segmented
modes of addressing and accessing data items and
instructions
encoding and representation
Instruction formats
Instruction set (or operation code)

ALU, control transfer, exceptional handling
Instruction Set-5
Computer Architecture
MIPS ISA as an Example

Instruction categories:






Registers
Load/Store
Computational
Jump and Branch
Floating Point
Memory Management
Special
$r0 - $r31
PC
HI
LO
3 Instruction Formats: all 32 bits wide
OP
$rs
$rt
OP
$rs
$rt
OP
$rd
sa
funct
immediate
jump target
Instruction Set-6
Computer Architecture
Outline












Instruction set architecture
Operands (Sec 2.2, 2.3)
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-7
Computer Architecture
Operations of Hardware

Syntax of basic MIPS arithmetic/logic instructions:
1
2
3
4
add $s0,$s1,$s2
# f = g + h
1) operation by name
2) operand getting result (“destination”)
3) 1st operand for operation (“source1”)
4) 2nd operand for operation (“source2”)


Each instruction is 32 bits
Syntax is rigid: 1 operator, 3 operands


Why? Keep hardware simple via regularity
Design Principle 1: Simplicity favors regularity


Regularity makes implementation simpler
Simplicity enables higher performance at lower cost
Instruction Set-8
Computer Architecture
Example

How to do the following C statement?
f
= (g + h) - (i + j);
Compiled MIPS code:
add t0, g, h
add t1, i, j
sub f, t0, t1
# temp t0 = g + h
# temp t1 = i + j
# f = t0 - t1
Instruction Set-9
Computer Architecture
Operands and Registers

Unlike high-level language, assembly don’t use
variables
=> assembly operands are registers



Limited number of special locations built directly into
the hardware
Operations are performed on these
Benefits:


Registers in hardware => faster than memory
Registers are easier for a compiler to use


e.g., as a place for temporary storage
Registers can hold variables to reduce memory traffic
and improve code density (since register named with
fewer bits than memory location)
Instruction Set-10
Computer Architecture
MIPS Registers

32 registers, each is 32 bits wide








Why 32? Design Principle 2: smaller is faster
Groups of 32 bits called a word in MIPS
Registers are numbered from 0 to 31
Each can be referred to by number or name
Number references:
$0, $1, $2, … $30, $31
By convention, each register also has a name to make
it easier to code, e.g.,
$16 - $22 
$s0 - $s7 (C variables)
$8 - $15

$t0 - $t7 (temporary)
32 x 32-bit FP registers (paired DP)
Others: HI, LO, PC
Instruction Set-11
Computer Architecture
Registers Conventions for MIPS
0
zero constant 0
16 s0 callee saves
1
at
...
2
v0 expression evaluation &
23 s7
3
v1 function results
24 t8
4
a0 arguments
25 t9
5
a1
26 k0 reserved for OS kernel
6
a2
27 k1
7
a3
28 gp pointer to global area
8
t0
...
15 t7
reserved for assembler
(caller can clobber)
temporary (cont’d)
temporary: caller saves
29 sp stack pointer
(callee can clobber)
30 fp
frame pointer
31 ra
return address (HW)
Fig. 2.18
Instruction Set-12
Computer Architecture
Memory
MIPS R2000
Organization
CPU
Coprocessor 1 (FPU)
Registers
Registers
$0
$0
$31
$31
Arithmetic
unit
Multiply
divide
Lo
Fig. A.10.1
Arithmetic
unit
Hi
Coprocessor 0 (traps and memory)
Registers
BadVAddr
Cause
Status
EPC
Example

How to do the following C statement?
f


= (g + h) - (i + j);
f, …, j in $s0, …, $s4
use intermediate temporary register t0,t1
add $t0,$s1,$s2
add $t1,$s3,$s4
sub $s0,$t0,$t1
# t0 = g + h
# t1 = i + j
# f=(g+h)-(i+j)
Instruction Set-14
Computer Architecture
Operations of Hardware

Syntax of basic MIPS arithmetic/logic instructions:
1
2
3
4
add $s0,$s1,$s2
# f = g + h
1) operation by name
2) operand getting result (“destination”)
3) 1st operand for operation (“source1”)
4) 2nd operand for operation (“source2”)


Each instruction is 32 bits
Syntax is rigid: 1 operator, 3 operands


Why? Keep hardware simple via regularity
Design Principle 1: Simplicity favors regularity


Regularity makes implementation simpler
Simplicity enables higher performance at lower cost
Instruction Set-15
Computer Architecture
Register Architecture

Accumulator (1 register):
1 address:
add A acc  acc + mem[A]
1+x address: addx A acc  acc + mem[A+x]

Stack:
0 address:

tos  tos + next
General Purpose Register:
2 address:
3 address:

add
add A,B
EA(A)  EA(A) + EA(B)
add A,B,C EA(A)  EA(B) + EA(C)
Load/Store: (a special case of GPR)
3 address:
add
load
store
$ra,$rb,$rc $ra  $rb + $rc
$ra,$rb
$ra  mem[$rb]
$ra,$rb
mem[$rb]  $ra
Instruction Set-16
Computer Architecture
Register Organization Affects
Programming
Code for C = A + B for four register organizations:
Stack Accumulator
Register
Register
(reg-mem)
(load-store)
Push A
Load A
Load $r1,A Load $r1,A
Push B
Add B
Add $r1,B
Load $r2,B
Add
Store C
Store C,$r1
Add $r3,$r1,$r2
Pop C
Store C,$r3
=> Register organization is an attribute of ISA!
Comparison: Byte per instruction? Number of
instructions? Cycles per instruction?
Since 1975 all machines use GPRs
Instruction Set-17
Computer Architecture
Outline












Instruction set architecture
Operands (Sec 2.2, 2.3)
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-18
Computer Architecture
Memory Operands

C variables map onto registers; what about large
data structures like arrays?


Memory contains such data structures
But MIPS arithmetic instructions operate on registers,
not directly on memory


Data transfer instructions (lw, sw, ...) to transfer between
memory and register
A way to address memory operands
Instruction Set-19
Computer Architecture
Data Transfer: Memory to Register
(1/2)

To transfer a word of data, need to specify two things:


Register: specify this by number (0 - 31)
Memory address: more difficult
 Think of memory as a 1D array
 Address it by supplying a pointer to a memory
address
 Offset (in bytes) from this pointer
 The desired memory address is the sum of these two
values, e.g., 8($t0)
 Specifies the memory address pointed to by the
value in $t0, plus 8 bytes (why “bytes”, not
“words”?)
 Each address is 32 bits
Instruction Set-20
Computer Architecture
Data Transfer: Memory to Register
(2/2)

Load Instruction Syntax:
1
2
3
4
lw $t0,12($s0)


1) operation name
2) register that will receive value
3) numerical offset in bytes
4) register containing pointer to memory
Example: lw $t0,12($s0)
 lw (Load Word, so a word (32 bits) is loaded at a time)
 Take the pointer in $s0, add 12 bytes to it, and then load the
value from the memory pointed to by this calculated sum
into register $t0
Notes:
 $s0 is called the base register, 12 is called the offset
 Offset is generally used in accessing elements of array:
base register points to the beginning of the array
Instruction Set-21
Computer Architecture
Example
 $s0
 lw
= 1000
Memory
‧
‧
‧
1000
$t0, 12($s0)
1004
 $t0
=?
1008
1012
999
1016
‧
‧
‧
Instruction Set-22
Computer Architecture
Data Transfer: Register to Memory



Also want to store value from a register into memory
Store instruction syntax is identical to Load instruction
syntax
Example: sw $t0,12($s0)


sw (meaning Store Word, so 32 bits or one word are
stored at a time)
This instruction will take the pointer in $s0, add 12 bytes
to it, and then store the value from register $t0 into the
memory address pointed to by the calculated sum
Instruction Set-23
Computer Architecture
Example
 $s0
= 1000
 $t0 = 25
 sw
Memory
‧
‧
‧
1000
$t0, 12($s0)
1004
1008
 M[?]
= 25
1012
1016
‧
‧
‧
Instruction Set-24
Computer Architecture
Compilation with Memory

Compile by hand using registers:
$s1:g, $s2:h, $s3:base address of A
g = h + A[8];

What offset in lw to select an array element A[8] in a
C program?


4x8=32 bytes to select A[8]
1st transfer from memory to register:
lw


$t0,32($s3)
# $t0 gets A[8]
Add 32 to $s3 to select A[8], put into $t0
Next add it to h and place in g
add $s1,$s2,$t0
# $s1 = h+A[8]
Instruction Set-25
Computer Architecture
Memory Operand Example 2

C code:
A[12] = h + A[8];


h in $s2, base address of A in $s3
Compiled MIPS code:

Index 8 requires offset of 32
lw $t0, 32($s3)
add $t0, $s2, $t0
sw $t0, 48($s3)
# load word
# store word
Instruction Set-26
Computer Architecture
Addressing: Byte versus Word


Every word in memory has an address, similar to an
index in an array
Early computers numbered words like C numbers
elements of an array:

Memory[0], Memory[1], Memory[2], …
Called the “address” of a word


Computers need to access 8-bit bytes as well as words
(4 bytes/word)
Today, machines address memory as bytes, hence
word addresses differ by 4


Memory[0], Memory[4], Memory[8], …
This is also why lw and sw use bytes in offset
Instruction Set-27
Computer Architecture
A Note about Memory: Alignment

MIPS requires that all words start at addresses that are
multiples of 4 bytes
0
1
2
3
Aligned
Not
Aligned

Called Alignment: objects must fall on address that is
multiple of their size
Instruction Set-28
Computer Architecture
Another Note: Endianess


Byte order: numbering of bytes within a word
Big Endian: address of most significant byte at least
address of a word


IBM 360/370, Motorola 68k, MIPS, Sparc, HP PA
Little Endian: address of least significant byte at least
address

Intel 80x86, DEC Vax, DEC Alpha (Windows NT)
little endian byte 0
3
2
1
0
msb
0
1
big endian byte 0
lsb
2
3
word address
Instruction Set-29
Computer Architecture
Role of Registers vs. Memory

What if more variables than registers?



Compiler tries to keep most frequently used variables
in registers
Writes less common variables to memory: spilling
Why not keep all variables in memory?


Smaller is faster:
registers are faster than memory
Registers more versatile:


MIPS arithmetic instructions can read 2 registers, operate
on them, and write 1 per instruction
MIPS data transfers only read or write 1 operand per
instruction, and no operation
Instruction Set-30
Computer Architecture
Outline












Instruction set architecture
Operands (Sec 2.2, 2.3)
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-31
Computer Architecture
Constants




Small constants used frequently (50% of operands)
e.g., A = A + 5;
B = B + 1;
C = C - 18;
Put 'typical constants' in memory and load them
Constant data specified in an instruction:
addi $29, $29, 4
slti $8, $18, 10
andi $29, $29, 6
ori $29, $29, 4
Design Principle 3: Make the common case fast
Instruction Set-32
Computer Architecture
Immediate Operands

Immediate: numerical constants




Often appear in code, so there are special instructions
for them
Add Immediate:
f = g + 10
(in C)
addi $s0,$s1,10
(in MIPS)
where $s0,$s1 are associated with f,g
Syntax similar to add instruction, except that last
argument is a number instead of a register
No subtract immediate instruction
 Just use a negative constant
addi $s2, $s1, -1
Instruction Set-33
Computer Architecture
The Constant Zero


The number zero (0), appears very often in code; so
we define register zero
MIPS register 0 ($zero) is the constant 0



Cannot be overwritten
This is defined in hardware, so an instruction like
addi $0,$0,5 will not do anything
Useful for common operations

E.g., move between registers
add $t2, $s1, $zero
Instruction Set-34
Computer Architecture
Outline












Instruction set architecture
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers (Sec 2.4, read by students)
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-35
Computer Architecture
Outline












Instruction set architecture
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions (Sec 2.5)
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-36
Computer Architecture
Instructions as Numbers

Currently we only work with words (32-bit blocks):



Each register is a word
lw and sw both access memory one word at a time
So how do we represent instructions?


Remember: Computer only understands 1s and 0s, so
“add $t0,$0,$0” is meaningless to hardware
MIPS wants simplicity: since data is in words, make
instructions be words…
Instruction Set-37
Computer Architecture
MIPS Instruction Format

One instruction is 32 bits
=> divide instruction word into “fields”


Each field tells computer something about instruction
We could define different fields for each instruction,
but MIPS is based on simplicity, so define 3 basic
types of instruction formats:



R-format: for register
I-format: for immediate, and lw and sw (since the offset
counts as an immediate)
J-format: for jump
Instruction Set-38
Computer Architecture
R-Format Instructions (1/2)

Define the following “fields”:
6
opcode





5
rs
5
rt
5
rd
5
shamt
6
funct
opcode: partially specifies what instruction it is (Note: 0
for all R-Format instructions)
funct: combined with opcode to specify the instruction
Question: Why aren’t opcode and funct a single 12-bit
field?
rs (Source Register): generally used to specify register
containing first operand
rt (Target Register): generally used to specify register
containing second operand
rd (Destination Register): generally used to specify
register which will receive result of computation
Instruction Set-39
Computer Architecture
R-Format Instructions (2/2)

Notes about register fields:


Each register field is exactly 5 bits, which means that it
can specify any unsigned integer in the range 0-31.
Each of these fields specifies one of the 32 registers by
number.
Final field:


shamt: contains the amount a shift instruction will shift
by. Shifting a 32-bit word by more than 31 is useless, so
this field is only 5 bits
This field is set to 0 in all but the shift instructions
Instruction Set-40
Computer Architecture
R-format Example
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
add $t0, $s1, $s2
Special
$s1
$s2
$t0
0
add
0
17
18
8
0
32
000000
10001
10010
01000
00000
100000
000000100011001001000000001000002 = 0232402016
Instruction Set-41
Computer Architecture
Hexadecimal

Base 16


0
1
2
3

Compact representation of bit strings
4 bits per hex digit
0000
0001
0010
0011
4
5
6
7
0100
0101
0110
0111
8
9
a
b
1000
1001
1010
1011
c
d
e
f
1100
1101
1110
1111
Example: eca8 6420

1110 1100 1010 1000 0110 0100 0010 0000
Instruction Set-42
Computer Architecture
I-Format Instructions

Define the following “fields”:
6
opcode





5
rs
5
rt
16
immediate
opcode: uniquely specifies an I-format instruction
rs: specifies the only register operand
rt: specifies register which will receive result of
computation (target register)
addi, slti, immediate is sign-extended to 32 bits, and
treated as a signed integer
16 bits  can be used to represent immediate up to 216
different values
Instruction Set-43
Computer Architecture
MIPS I-format Instructions

Design Principle 4: Good design demands good
compromises
 Different formats complicate decoding, but allow
32-bit instructions uniformly
 Keep formats as similar as possible
Instruction Set-44
Computer Architecture
I-Format Example 1

MIPS Instruction:
addi
$21,$22,-50
 opcode = 8 (look up in table)
 rs = 22 (register containing operand)
 rt = 21 (target register)
 immediate = -50 (by default, this is decimal)
decimal representation:
8
22
21
-50
binary representation:
001000 10110 10101
1111111111001110
Instruction Set-45
Computer Architecture
I-Format Example 2

MIPS Instruction:
lw
$t0,1200($t1)
 opcode = 35 (look up in table)
 rs = 9 (base register)
 rt = 8 (destination register)
 immediate = 1200 (offset)
decimal representation:
35
9
8
1200
binary representation:
100011 01001 01000
0000010010110000
Instruction Set-46
Computer Architecture
Stored Program Computers
The BIG Picture



Instructions represented in
binary, just like data
Instructions and data stored in
memory
Programs can operate on
programs


e.g., compilers, linkers, …
Binary compatibility allows
compiled programs to work on
different computers

Standardized ISAs
Instruction Set-47
Computer Architecture
Outline












Instruction set architecture
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical (Sec 2.6)
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-48
Computer Architecture
Bitwise Operations





Up until now, we’ve done arithmetic (add, sub, addi)
and memory access (lw and sw)
All of these instructions view contents of register as a
single quantity (such as a signed or unsigned integer)
New perspective: View contents of register as 32 bits
rather than as a single 32-bit number
Since registers are composed of 32 bits, we may
want to access individual bits rather than the whole.
Introduce two new classes of instructions:


Shift instructions
Logical operators
Instruction Set-49
Computer Architecture
Logical Operations


Instructions for bitwise manipulation
Operation
C
Java
MIPS
Shift left
<<
<<
sll
Shift right
>>
>>>
srl
Bitwise AND
&
&
and, andi
Bitwise OR
|
|
or, ori
Bitwise NOT
~
~
nor
Useful for extracting and inserting groups of bits in a
word
Instruction Set-50
Computer Architecture
Shift Operations


rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
shamt: how many positions to shift
Shift left logical



op
Shift left and fill with 0 bits
sll by i bits multiplies by 2i
Shift right logical


Shift right and fill with 0 bits
srl by i bits divides by 2i (unsigned only)
Instruction Set-51
Computer Architecture
Shift Instructions (1/3)

Shift Instruction Syntax:
1
2
3
sll
4
$t2,$s0,4
1) operation name
2) register that will receive value
3) first operand (register)
4) shift amount (constant)

MIPS has three shift instructions:



sll (shift left logical): shifts left, fills empties with 0s
srl (shift right logical): shifts right, fills empties with 0s
sra (shift right arithmetic): shifts right, fills empties by
sign extending
Instruction Set-52
Computer Architecture
Shift Instructions (2/3)


Move (shift) all the bits in a word to the left or right by
a number of bits, filling the emptied bits with 0s.
Example: shift right by 8 bits
0001 0010 0011 0100 0101 0110 0111 1000
0000 0000 0001 0010 0011 0100 0101 0110

Example: shift left by 8 bits
0001 0010 0011 0100 0101 0110 0111 1000
0011 0100 0101 0110 0111 1000 0000 0000
Instruction Set-53
Computer Architecture
Shift Instructions (3/3)

Example: shift right arithmetic by 8 bits
0001 0010 0011 0100 0101 0110 0111 1000
0000 0000 0001 0010 0011 0100 0101 0110

Example: shift right arithmetic by 8 bits
1001 0010 0011 0100 0101 0110 0111 1000
1111 1111 1001 0010 0011 0100 0101 0110
Instruction Set-54
Computer Architecture
Uses for Shift Instructions

Shift for multiplication: in binary

Multiplying by 4 is same as shifting left by 2:




112 x 1002 = 11002
10102 x 1002 = 1010002
Multiplying by 2n is same as shifting left by n
Since shifting is so much faster than multiplication
(you can imagine how complicated multiplication
is), a good compiler usually notices when C code
multiplies by a power of 2 and compiles it to a shift
instruction:
a *= 8;
would compile to:
sll
$s0,$s0,3
(in C)
(in MIPS)
Instruction Set-55
Computer Architecture
AND Operations

Useful to mask bits in a word
 Select some bits, clear others to 0
and $t0, $t1, $t2
$t2 0000 0000 0000 0000 0000 1101 1100 0000
$t1 0000 0000 0000 0000 0011 1100 0000 0000
$t0 0000 0000 0000 0000 0000 1100 0000 0000
Instruction Set-56
Computer Architecture
OR Operations

Useful to include bits in a word
 Set some bits to 1, leave others unchanged
or $t0, $t1, $t2
$t2 0000 0000 0000 0000 0000 1101 1100 0000
$t1 0000 0000 0000 0000 0011 1100 0000 0000
$t0 0000 0000 0000 0000 0011 1101 1100 0000
Instruction Set-57
Computer Architecture
NOT Operations


Useful to invert bits in a word
 Change 0 to 1, and 1 to 0
MIPS has NOR 3-operand instruction
 a NOR b == NOT ( a OR b )
nor $t0, $t1, $zero
Register 0: always
read as zero
$t1 0000 0000 0000 0000 0011 1100 0000 0000
$t0 1111 1111 1111 1111 1100 0011 1111 1111
Instruction Set-58
Computer Architecture
So Far...



All instructions have allowed us to manipulate data.
So we’ve built a calculator.
In order to build a computer, we need ability to
make decisions…
Instruction Set-59
Computer Architecture
Outline












Instruction set architecture
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches (Sec 2.7)
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-60
Computer Architecture
MIPS Decision Instructions
beq

register1, register2, L1
Decision instruction in MIPS:
beq
register1, register2, L1
“Branch if (registers are) equal”
meaning :
if (register1==register2) goto L1

Complementary MIPS decision instruction
bne
register1, register2, L1
“Branch if (registers are) not equal”
meaning :
if (register1!=register2) goto L1

These are called conditional branches
Instruction Set-61
Computer Architecture
MIPS Goto Instruction
j

MIPS has an unconditional branch:
j
label




label
Called a Jump Instruction: jump directly to the given
label without testing any condition
meaning :
goto label
Technically, it’s the same as:
beq
$0,$0,label
since it always satisfies the condition
It has the j-type instruction format
Instruction Set-62
Computer Architecture
Compiling C if into MIPS

Compile by hand
if (i == j) f=g+h;
else f=g-h;

Use this mapping:

Final compiled MIPS code:
f, g.., j : $s0,$s1, $s2,
$s3, $s4
Else:
Exit:
bne
add
j
sub
$s3,$s4,Else
$s0,$s1,$s2
Exit
$s0,$s1,$s2
(true)
i == j
i == j?
f=g+h
#
#
#
#
(false)
i != j
f=g-h
Exit
branch i!=j
f=g+h(true)
go to Exit
f=g-h (false)
Note: Compiler automatically creates labels to handle
decisions (branches) appropriately
Instruction Set-63
Computer Architecture
Compiling Loop Statements

C code:
while (save[i] == k) i += 1;


i in $s3, k in $s5, address of save in $s6
Compiled MIPS code:
Loop:
Exit: …
sll
add
lw
bne
addi
j
$t1,
$t1,
$t0,
$t0,
$s3,
Loop
$s3, 2
$t1, $s6
0($t1)
$s5, Exit
$s3, 1
Instruction Set-64
#$t1=i x 4
#$t1=addr of save[i]
#$t0=save[i]
#if save[i]!=k goto Exit
#i=i+1
#goto Loop
Computer Architecture
Basic Blocks

A basic block is a sequence of instructions with


No embedded branches (except at end)
No branch targets (except at beginning)


A compiler identifies basic
blocks for optimization
An advanced processor can
accelerate execution of basic
blocks
Instruction Set-65
Computer Architecture
Inequalities in MIPS


Until now, we’ve only tested equalities (== and != in
C), but general programs need to test < and >
Set on Less Than:


slt rd, rs, rt
 if (rs < rt) rd = 1; else rd = 0;
slti rt, rs, constant
 if (rs < constant) rt = 1; else rt = 0;
Compile by hand: if (g < h) goto Less;
Let g: $s0, h: $s1
slt $t0,$s0,$s1
bne $t0,$0,Less

# $t0 = 1 if g<h
# goto Less if $t0!=0
MIPS has no “branch on less than” => too complex
Instruction Set-66
Computer Architecture
Branch Instruction Design


Why not blt, bge, etc?
Hardware for <, ≥, … slower than =, ≠




Combining with branch involves more work per
instruction, requiring a slower clock
All instructions penalized!
beq and bne are the common case
This is a good design compromise
Instruction Set-67
Computer Architecture
Signed vs. Unsigned



Signed comparison: slt, slti
Unsigned comparison: sltu, sltui
Example



$s0 = 1111 1111 1111 1111 1111 1111 1111 1111
$s1 = 0000 0000 0000 0000 0000 0000 0000 0001
slt $t0, $s0, $s1 # signed


–1 < +1  $t0 = 1
sltu $t0, $s0, $s1

# unsigned
+4,294,967,295 > +1  $t0 = 0
Instruction Set-68
Computer Architecture
Outline












Instruction set architecture (using MIPS ISA as an example)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware (Sec. 2.8)
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-69
Computer Architecture
Procedure Calling

Steps required
Caller:
1. Place parameters in registers
2. Transfer control to procedure
Callee:
3. Acquire storage for procedure
4. Perform procedure’s operations
5. Place result in register for caller
6. Return to place of call
Instruction Set-70
Computer Architecture
C Function Call Bookkeeping
sum = leaf_example(a,b,c,d) . . .
int leaf_example (int g, h, i, j)
{ int f;
f = (g + h) - (i + j);
return f;
}
Return address
$ra
 Procedure address
Labels
 Arguments
$a0, $a1, $a2, $a3
 Return value
$v0, $v1
 Local variables
$s0, $s1, …, $s7
Note the use of register conventions

Instruction Set-71
Computer Architecture
Registers Conventions for MIPS
0
zero constant 0
16 s0 callee saves
1
at
...
2
v0 expression evaluation &
23 s7
3
v1 function results
24 t8
4
a0 arguments
25 t9
5
a1
26 k0 reserved for OS kernel
6
a2
27 k1
7
a3
28 gp pointer to global area
8
t0
...
15 t7
reserved for assembler
(caller can clobber)
temporary (cont’d)
temporary: caller saves
29 sp stack pointer
(callee can clobber)
30 fp
frame pointer
31 ra
return address (HW)
Fig. 2.18
Instruction Set-72
Computer Architecture
Procedure Call Instructions


Procedure call: jump and link
jal ProcedureLabel
 Address of following instruction put in $ra
 Jumps to target address (i.e.,ProcedureLabel)
Procedure return: jump register
jr $ra
 Copies $ra to program counter
 Can also be used for computed jumps
 e.g., for case/switch statements
 Jump table is an array of addresses
corresponding to labels in codes
 Load appropriate entry to register
 Jump register
Instruction Set-73
Computer Architecture
Caller’s Code

. . .
sum = leaf_example(a,b,c,d)
. . .

MIPS code: a, …, d in $s0, …, $s3, and sum in $s4
:
add
add
add
add
jal
add
$a0, $0, $s0
$a1, $0, $s1
$a2, $0, $s2
$a3, $0, $s3
leaf_example
$s4, $0, $v0
Move a,b,c,d to a0..a3
Jump to leaf_example
Move result in v0 to sum
:
Instruction Set-74
Computer Architecture
Leaf Procedure Example

C code:
int leaf_example (int g, h, i, j)
{ int f;
f = (g + h) - (i + j);
return f;
}
 Arguments g, …, j in $a0, …, $a3
 f in $s0 (hence, need to save $s0 on stack)
 Save $t1 and $t2
 Result in $v0
Instruction Set-75
Computer Architecture
Leaf Procedure Example

MIPS code:
leaf_example:
addi $sp, $sp, -12
sw
$s0, 0($sp)
sw
$t0, 4($sp)
sw
$t1, 8($sp)
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero
lw
$s0, 0($sp)
lw
$t0, 4($sp)
lw
$t1, 8($sp)
addi $sp, $sp, 12
jr
$ra
Instruction Set-76
Save $s0 $t0 $t1 on stack
Procedure body
Result
Restore $s0 $t0 $t1
Return
Computer Architecture
Leaf Procedure Example

C code:
int leaf_example (int g, h, i, j)
{ int f;
f = (g + h) - (i + j);
return f;
}
 Arguments g, …, j in $a0, …, $a3
 f in $s0 (hence, need to save $s0 on stack)
 $t1 and $t2 are not saved on stack
 Result in $v0
Instruction Set-77
Computer Architecture
Leaf Procedure Example

MIPS code:
leaf_example:
addi $sp, $sp, -4
sw
$s0, 0($sp)
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero
lw
$s0, 0($sp)
addi $sp, $sp, 4
jr
$ra
Instruction Set-78
Save $s0 on stack
Procedure body
Result
Restore $s0
Return
Computer Architecture
Local Data on the Stack
High address
High address
$sp
High address
$sp
$sp
Contents of $s0
Instruction Set-79
Computer Architecture
Non-Leaf Procedures



Procedures that call other procedures
For nested call, caller needs to save on the
stack:
 Its return address
 Any arguments and temporaries needed
after the call (because callee will not save
them)
Restore from the stack after the call
Instruction Set-80
Computer Architecture
Non-Leaf Procedure Example

C code:
int fact (int n)
{
if (n < 1) return 1;
else return n * fact(n - 1);
}
 Argument n in $a0
 Result in $v0
Instruction Set-81
Computer Architecture
Non-Leaf Procedure Example

MIPS code:
fact:
addi
sw
sw
slti
beq
addi
addi
jr
L1: addi
jal
lw
lw
addi
mul
jr
$sp,
$ra,
$a0,
$t0,
$t0,
$v0,
$sp,
$ra
$a0,
fact
$a0,
$ra,
$sp,
$v0,
$ra
$sp, -8
4($sp)
0($sp)
$a0, 1
$zero, L1
$zero, 1
$sp, 8
$a0, -1
0($sp)
4($sp)
$sp, 8
$a0, $v0
#
#
#
#
adjust stack for 2 items
save return address
save argument
test for n < 1
#
#
#
#
#
#
#
#
#
#
if so, result is 1
pop 2 items from stack
and return
else decrement n
recursive call
restore original n
and return address
pop 2 items from stack
multiply to get result
and return
Instruction Set-82
Computer Architecture
Local Data on the Stack


Local data allocated by callee
 e.g., C automatic variables
Procedure frame (activation record)
 Used by some compilers to manage stack storage
Instruction Set-83
Computer Architecture
Memory Layout




Text: program code
Static data: global variables
 e.g., static variables in C,
constant arrays and
strings
 $gp initialized to address
allowing ±offsets into this
segment
Dynamic data: heap
 E.g., malloc in C, new in
Java
Stack: automatic storage
Instruction Set-84
Computer Architecture
Why Procedure Conventions?



Definitions
 Caller: function making the call, using jal
 Callee: function being called
Procedure conventions as a contract between the
Caller and the Callee
If both the Caller and Callee obey the procedure
conventions, there are significant benefits
 People who have never seen or even
communicated with each other can write
functions that work together
 Recursion functions work correctly
Instruction Set-85
Computer Architecture
Caller’s Rights, Callee’s Rights

Callees’ rights:



To ensure callees’s right, caller saves registers:





Return address
Arguments
Return value
$t Registers
$ra
$a0, $a1, $a2, $a3
$v0, $v1
$t0 - $t9
Callers’ rights:



Right to use VAT registers freely
Right to assume arguments are passed correctly
Right to use S registers without fear of being overwritten
by callee
Right to assume return value will be returned correctly
To ensure caller’s right, callee saves registers:

$s Registers
$s0 - $s7
Instruction Set-86
Computer Architecture
Contract in Function Calls (1/2)

Caller’s responsibilities (how to call a function)







Slide $sp down to reserve memory:
e.g., addi $sp, $sp, -28
Save $ra on stack because jal clobbers it:
e.g., sw $ra, 24 ($sp)
If still need their values after function call, save $v,
$a, $t on stack or copy to $s registers
Put first 4 words of arguments in $a0-3, additional
arguments go on stack: “a4” is 16($sp)
jal to the desired function
Receive return values in $v0, $v1
Undo first steps: e.g. lw $t0, 20($sp) lw $ra,
24($sp) addi $sp, $sp, 28
Instruction Set-87
Computer Architecture
Contract in Function Calls (2/2)
 Callee’s responsibilities (i.e. how to write a function)







If using $s or big local structures, slide $sp down to
reserve memory: e.g., addi $sp, $sp, -48
If using $s, save before using: e.g.,
sw $s0, 44($sp)
Receive arguments in $a0-3, additional arguments on
stack
Run the procedure body
If not void, put return values in $v0,1
If applicable, undo first two steps: e.g.,
lw $s0, 44($sp)
addi $sp, $sp, 48
jr $ra
Instruction Set-88
Computer Architecture
Outline












Instruction set architecture (using MIPS ISA as an example)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people (Sec. 2.9)
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-89
Computer Architecture
Character Data


Byte-encoded character sets
 ASCII: 128 characters
 95 graphic, 33 control
 Latin-1: 256 characters
 ASCII, +96 more graphic characters
Unicode: 32-bit character set
 Used in Java, C++ wide characters, …
 Most of the world’s alphabets, plus symbols
 UTF-8, UTF-16: variable-length encodings
Instruction Set-90
Computer Architecture
Byte/Halfword Operations



Could use bitwise operations
MIPS byte/halfword load/store
String processing is a common case
lb rt, offset(rs)
lh rt, offset(rs)
 Sign extend to 32 bits in rt
lbu rt, offset(rs)
lhu rt, offset(rs)
 Zero extend to 32 bits in rt
sb rt, offset(rs)
sh rt, offset(rs)
 Store just rightmost byte/halfword
Instruction Set-91
Computer Architecture
Load Byte Signed/Unsigned
$t0
… 12 F7 F0 …
lb $t1, 0($t0)
$t1
?
Sign-extended
lbu $t2, 0($t0)
$t2
?
Zero-extended
Instruction Set-92
Computer Architecture
String Copy Example

C code (naïve):
 Null-terminated string
void strcpy (char x[], char y[])
{ int i;
i = 0;
while ((x[i]=y[i])!='\0')
i += 1;
}
 Addresses of x, y in $a0, $a1
 i in $s0
Instruction Set-93
Computer Architecture
String Copy Example

MIPS code:
strcpy:
addi
sw
add
L1: add
lbu
add
sb
beq
addi
j
L2: lw
addi
jr
$sp,
$s0,
$s0,
$t1,
$t2,
$t3,
$t2,
$t2,
$s0,
L1
$s0,
$sp,
$ra
$sp, -4
0($sp)
$zero, $zero
$s0, $a1
0($t1)
$s0, $a0
0($t3)
$zero, L2
$s0, 1
0($sp)
$sp, 4
#
#
#
#
#
#
#
#
#
#
#
#
#
Instruction Set-94
adjust stack for 1 item
save $s0
i = 0
addr of y[i] in $t1
$t2 = y[i]
addr of x[i] in $t3
x[i] = y[i]
exit loop if y[i] == 0
i = i + 1
next iteration of loop
restore saved $s0
pop 1 item from stack
and return
Computer Architecture
Outline












Instruction set architecture (using MIPS ISA as an example)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses (Sec. 2.10)
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-95
Computer Architecture
32-bit Constants



Most constants are small
 16-bit immediate is sufficient
For the occasional 32-bit constant
Load Upper Immediate:
lui rt, constant


Copies 16-bit constant to left 16 bits of rt
Clears right 16 bits of rt to 0
machine version of lui
001111 00000 10000 0000 0000 0011 1101
lui $s0, 61
0000 0000 0011 1101 0000 0000 0000 0000 S0
ori $s0, $s0, 2304
0000 0000 0011 1101 0000 1001 0000 0000 S0
Instruction Set-96
Computer Architecture
Branch Addressing (1)

Use I-format:
opcode



rs
rt
immediate
opcode specifies beq or bne
Rs and Rt specify registers to compare
What can immediate specify? PC-relative addressing


Immediate is only 16 bits, but PC is 32-bit
=> immediate cannot specify entire address
Loops are generally small: < 50 instructions


Though we want to branch to anywhere in memory, a
single branch only need to change PC by a small
amount
How to use PC-relative addressing


16-bit immediate as a signed two’s complement integer
to be added to the PC if branch taken
15 bytes from the PC ?
Now we can branchInstruction
+/- 2Set-97
Computer Architecture
Branch Addressing (2)

Immediate specifies word address

Instructions are word aligned (byte address is always a
multiple of 4, i.e., it ends with 00 in binary)




The number of bytes to add to the PC will always be a
multiple of 4
Specify the immediate in words (confusing?)
Now, we can branch +/- 215 words from the PC (or +/217 bytes), handle loops 4 times as large
Immediate specifies PC + 4



Due to hardware, add immediate to (PC+4), not to PC
If branch not taken: PC = PC + 4
If branch taken: PC = (PC+4) + (immediate*4)
Instruction Set-98
Computer Architecture
Branch Example

MIPS Code:
Loop: beq
add
addi
j
End:

$9,$0,End
$8,$8,$10
$9,$9,-1
Loop
Branch is I-Format:
opcode
rs
rt
immediate
opcode = 4 (look up in table)
rs = 9 (first operand)
rt = 0 (second operand)
immediate = ???
 Number of instructions to add to (or subtract from) the
PC, starting at the instruction following the branch
=> immediate = ?
Instruction Set-99
Computer Architecture
Branch Example

MIPS Code:
Loop: beq
add
addi
j
End:
$9,$0,End
$8,$8,$10
$9,$9,-1
Loop
decimal representation:
4
9
0
3
binary representation:
000100 01001 00000
0000000000000011
Instruction Set-100
Computer Architecture
Jump Addressing (1/3)




For branches, we assumed that we won’t want to
branch too far, so we can specify change in PC.
For general jumps (j and jal), we may jump to
anywhere in memory.
Ideally, we could specify a 32-bit memory address to
jump to.
Unfortunately, we can’t fit both a 6-bit opcode and a
32-bit address into a single 32-bit word, so we
compromise.
Instruction Set-101
Computer Architecture
Jump Addressing (2/3)

Define “fields” of the following number of bits each:
6 bits

As usual, each field has a name:
opcode

target address
Key concepts:



26 bits
Keep opcode field identical to R-format and I-format for
consistency
Combine other fields to make room for target address
Optimization:

Jumps only jump to word aligned addresses


last two bits are always 00 (in binary)
specify 28 bits of the 32-bit bit address
Instruction Set-102
Computer Architecture
Jump Addressing (3/3)

Where do we get the other 4 bits?




Summary:



Take the 4 highest order bits from the PC
Technically, this means that we cannot jump to
anywhere in memory, but it’s adequate 99.9999…% of
the time, since programs aren’t that long
Linker and loader avoid placing a program across an
address boundary of 256 MB
New PC = PC[31..28] || target address (26 bits) || 00
Note: II means concatenation
4 bits || 26 bits || 2 bits = 32-bit address
If we absolutely need to specify a 32-bit address:

Use jr $ra
# jump to the address specified by $ra
Instruction Set-103
Computer Architecture
Target Addressing Example

Loop code from earlier example
 Assume Loop at location 80000
$t1, $s3, 2
80000
0
0
19
9
4
0
add
$t1, $t1, $s6
80004
0
9
22
9
0
32
lw
$t0, 0($t1)
80008
35
9
8
0
bne
$t0, $s5, Exit
80012
5
8
21
2
addi $s3, $s3, 1
80016
8
19
19
1
j
80020
2
Loop: sll
Loop
80024
Exit: …


20000
80016 + 2 x 4 = 80024
20000 x 4 = 80000
Instruction Set-104
Computer Architecture
Branching Far Away


If branch target is too far to encode with 16-bit offset,
assembler rewrites the code
Example
beq $s0,$s1, L1
↓
bne $s0,$s1, L2
j L1
L2: …
Instruction Set-105
Computer Architecture
MIPS Addressing Mode
Instruction Set-106
Computer Architecture
MPIS Addressing Modes
Instruction Set-107
Computer Architecture
Outline












Instruction set architecture (using MIPS ISA as an example)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program (Sec. 2.12)
A sort example
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-108
Computer Architecture
Translation and Startup
Many compilers produce
object modules directly
Static linking
Instruction Set-109
Computer Architecture
Assembler Pseudoinstructions


Most assembler instructions represent machine
instructions one-to-one
Pseudo instructions: figments of the assembler’s
imagination
move $t0, $t1
→ add $t0, $zero, $t1
blt $t0, $t1, L → slt $at, $t0, $t1
bne $at, $zero, L
 $at (register 1): assembler temporary
Instruction Set-110
Computer Architecture
Producing an Object Module


Assembler (or compiler) translates program into
machine instructions
Provides information for building a complete
program from the pieces






Header: described contents of object module
Text segment: translated instructions
Static data segment: data allocated for the life of the
program
Relocation info: for contents that depend on absolute
location of loaded program
Symbol table: global definitions and external refs
Debug info: for associating with source code
Instruction Set-111
Computer Architecture
Linking Object Modules


Produces an executable image
1.Merges segments
2.Resolve labels (determine their addresses)
3.Patch location-dependent and external refs
Could leave location dependencies for fixing by a
relocating loader
 But with virtual memory, no need to do this
 Program can be loaded into absolute location in
virtual memory space
Instruction Set-112
Computer Architecture
Loading a Program

Load from image file on disk into memory
1.Read header to determine segment sizes
2.Create virtual address space
3.Copy text and initialized data into memory
 Or set page table entries so they can be faulted
in
4.Set up arguments on stack
5.Initialize registers (including $sp, $fp, $gp)
6.Jump to startup routine
 Copies arguments to $a0, … and calls main
 When main returns, do exit syscall
Instruction Set-113
Computer Architecture
Outline












Instruction set architecture (using MIPS ISA as an example)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example (Sec. 2.13)
Arrays versus pointers
ARM and x86 instruction sets
Instruction Set-114
Computer Architecture
C Sort Example


Illustrates use of assembly instructions for a C
bubble sort function
Swap procedure (leaf)
void swap(int v[], int k)
{
int temp;
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
}
 v in $a0, k in $a1, temp in $t0
Instruction Set-115
Computer Architecture
The Procedure Swap
swap: sll $t1, $a1, 2
# $t1 = k * 4
add $t1, $a0, $t1 # $t1 = v+(k*4)
#
(address of v[k])
lw $t0, 0($t1)
# $t0 (temp) = v[k]
lw $t2, 4($t1)
# $t2 = v[k+1]
sw $t2, 0($t1)
# v[k] = $t2 (v[k+1])
sw $t0, 4($t1)
# v[k+1] = $t0 (temp)
jr $ra
# return to calling routine
Instruction Set-116
Computer Architecture
The Sort Procedure in C

Non-leaf (calls swap)
void sort (int v[], int n)
{
int i, j;
for (i = 0; i < n; i += 1) {
for (j = i – 1;
j >= 0 && v[j] > v[j + 1];
j -= 1) {
swap(v,j);
}
}
}
 v in $a0, k in $a1, i in $s0, j in $s1
Instruction Set-117
Computer Architecture
The Procedure Body
move
move
move
for1tst: slt
beq
addi
for2tst: slti
bne
sll
add
lw
lw
slt
beq
move
move
jal
addi
j
exit2:
addi
j
$s2, $a0
$s3, $a1
$s0, $zero
$t0, $s0, $s3
$t0, $zero, exit1
$s1, $s0, –1
$t0, $s1, 0
$t0, $zero, exit2
$t1, $s1, 2
$t2, $s2, $t1
$t3, 0($t2)
$t4, 4($t2)
$t0, $t4, $t3
$t0, $zero, exit2
$a0, $s2
$a1, $s1
swap
$s1, $s1, –1
for2tst
$s0, $s0, 1
for1tst
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
save $a0 into $s2
Move
params
save $a1 into $s3
i = 0
Outer loop
$t0 = 0 if $s0 ≥ $s3 (i ≥ n)
go to exit1 if $s0 ≥ $s3 (i ≥ n)
j = i – 1
$t0 = 1 if $s1 < 0 (j < 0)
go to exit2 if $s1 < 0 (j < 0)
$t1 = j * 4
Inner loop
$t2 = v + (j * 4)
$t3 = v[j]
$t4 = v[j + 1]
$t0 = 0 if $t4 ≥ $t3
go to exit2 if $t4 ≥ $t3
1st param of swap is v (old $a0) Pass
2nd param of swap is j
params
& call
call swap procedure
j –= 1
Inner loop
jump to test of inner loop
i += 1
Outer loop
jump to test of outer loopComputer Architecture
Instruction Set-118
The Full Procedure
sort:
exit1:
addi $sp,$sp, –20
sw $ra, 16($sp)
sw $s3,12($sp)
sw $s2, 8($sp)
sw $s1, 4($sp)
sw $s0, 0($sp)
…
…
lw $s0, 0($sp)
lw $s1, 4($sp)
lw $s2, 8($sp)
lw $s3,12($sp)
lw $ra,16($sp)
addi $sp,$sp, 20
jr $ra
#
#
#
#
#
#
#
make room on stack for 5 registers
save $ra on stack
save $s3 on stack
save $s2 on stack
save $s1 on stack
save $s0 on stack
procedure body
#
#
#
#
#
#
#
restore $s0 from stack
restore $s1 from stack
restore $s2 from stack
restore $s3 from stack
restore $ra from stack
restore stack pointer
return to calling routine
Instruction Set-119
Computer Architecture
Effect of Compiler Optimization
Compiled with gcc for Pentium 4 under Linux
Relative Performance
3
140000
Instruction count
120000
2.5
100000
2
80000
1.5
60000
1
40000
0.5
20000
0
0
none
180000
160000
140000
120000
100000
80000
60000
40000
20000
0
O1
O2
none
O3
O1
O3
CPI
2
Clock Cycles
O2
1.5
1
0.5
0
none
O1
O2
O3
none
Instruction Set-120
O1
O2
O3
Computer Architecture
Effect of Language and Algorithm
Bubblesort Relative Performance
3
2.5
2
1.5
1
0.5
0
C/none
C/O1
C/O2
C/O3
Java/int
Java/JIT
Quicksort Relative Performance
2.5
2
1.5
1
0.5
0
C/none
C/O1
C/O2
C/O3
Java/int
Java/JIT
Quicksort vs. Bubblesort Speedup
3000
2500
2000
1500
1000
500
0
C/none
C/O1
C/O2
C/O3
Instruction Set-121
Java/int
Java/JIT
Computer Architecture
Lessons Learnt



Instruction count and CPI are not good performance
indicators in isolation
Compiler optimizations are sensitive to the algorithm
Nothing can fix a dumb algorithm!
Instruction Set-122
Computer Architecture
Outline












Instruction set architecture (using MIPS ISA as an example)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program (Sec. 2.12)
A sort example
Arrays versus pointers (Sec. 2.14)
ARM and x86 instruction sets
Instruction Set-123
Computer Architecture
Arrays vs. Pointers


Array indexing involves
 Multiplying index by element size
 Adding to array base address
Pointers correspond directly to memory addresses
 Can avoid indexing complexity
Instruction Set-124
Computer Architecture
Example: Clearing an Array
clear1(int array[], int size) {
int i;
for (i = 0; i < size; i += 1)
array[i] = 0;
}
clear2(int *array, int size) {
int *p;
for (p = &array[0]; p < &array[size];
p = p + 1)
*p = 0;
}
move $t0,$zero
loop1: sll $t1,$t0,2
add $t2,$a0,$t1
move $t0, $a0
# p = & array[0]
sll $t1, $a1, 2 # $t1 = size * 4
add $t2,$a0,$t1 # $t2 =
#
&array[size]
loop2: sw $zero,0($t0) # Memory[p] = 0
addi $t0,$t0,4 # p = p + 4
slt $t3,$t0,$t2 # $t3 =
#(p<&array[size])
bne $t3,$zero,loop2 # if (…)
# goto loop2
# i = 0
# $t1 = i * 4
# $t2 =
#
&array[i]
sw $zero, 0($t2) # array[i] = 0
addi $t0,$t0,1
# i = i + 1
slt $t3,$t0,$a1 # $t3 =
#
(i < size)
bne $t3,$zero,loop1 # if (…)
# goto loop1
Instruction Set-125
Computer Architecture
Comparison of Array vs. Ptr



Multiply “strength reduced” to shift (strength
reduction)
Array version requires shift to be inside loop
 Part of index calculation for incremented i
 c.f. incrementing pointer
Compiler can achieve same effect as manual use of
pointers
 Eliminating array address calculations within loop
(induction variable elimination): 6 instructions
reduced to 4 in loop
 Better to make program clearer and safer
Instruction Set-126
Computer Architecture
Outline












Instruction set architecture (using MIPS ISA as an example)
Operands
 Register operands and their organization
 Memory operands, data transfer
 Immediate operands
Signed and unsigned numbers
Representing instructions
Operations
 Logical
 Decision making and branches
Supporting procedures in hardware
Communicating with people
Addressing for 32-bit immediate and addresses
Translating and starting a program
A sort example
Arrays versus pointers
ARM and x86 instruction sets (Sec. 2.15, 2.16)
Instruction Set-127
Computer Architecture
ARM & MIPS Similarities


ARM: the most popular embedded core
Similar basic set of instructions to MIPS
ARM
MIPS
1985
1985
Instruction size
32 bits
32 bits
Address space
32-bit flat
32-bit flat
Data alignment
Aligned
Aligned
9
3
15 × 32-bit
31 × 32-bit
Memory mapped
Memory mapped
Date announced
Data addressing modes
Registers
Input/output
Instruction Set-128
Computer Architecture
Compare and Branch in ARM


Uses condition codes for result of an
arithmetic/logical instruction
 Negative, zero, carry, overflow
 Compare instructions to set condition codes
without keeping the result
Each instruction can be conditional
 Top 4 bits of instruction word: condition value
 Can avoid branches over single instructions
Instruction Set-129
Computer Architecture
Instruction Encoding
Instruction Set-130
Computer Architecture
The Intel x86 ISA

Evolution with backward compatibility
 8080 (1974): 8-bit microprocessor
 Accumulator, plus 3 index-register pairs
 8086 (1978): 16-bit extension to 8080
 Complex instruction set (CISC)
 8087 (1980): floating-point coprocessor
 Adds FP instructions and register stack
 80286 (1982): 24-bit addresses, MMU
 Segmented memory mapping and protection
 80386 (1985): 32-bit extension (now IA-32)
 Additional addressing modes and operations
 Paged memory mapping as well as segments
Instruction Set-131
Computer Architecture
The Intel x86 ISA

Further evolution…
 i486 (1989): pipelined, on-chip caches and FPU
 Compatible competitors: AMD, Cyrix, …
 Pentium (1993): superscalar, 64-bit datapath
 Later versions added MMX (Multi-Media
eXtension) instructions
 The infamous FDIV bug
 Pentium Pro (1995), Pentium II (1997)
 New microarchitecture (see Colwell, The
Pentium Chronicles)
 Pentium III (1999)
 Added SSE (Streaming SIMD Extensions) and
associated registers
 Pentium 4 (2001)
 New microarchitecture
Computer Architecture
Instruction Set-132
 Added SSE2 instructions
The Intel x86 ISA


And further…
 AMD64 (2003): extended architecture to 64 bits
 EM64T – Extended Memory 64 Technology (2004)
 AMD64 adopted by Intel (with refinements)
 Added SSE3 instructions
 Intel Core (2006)
 Added SSE4 instructions, virtual machine
support
 AMD64 (announced 2007): SSE5 instructions
 Intel declined to follow, instead…
 Advanced Vector Extension (announced 2008)
 Longer SSE registers, more instructions
If Intel didn’t extend with compatibility, its
competitors would!
 Technical elegance ≠ market success
Instruction Set-133
Computer Architecture
Basic x86 Registers
Instruction Set-134
Computer Architecture
Basic x86 Addressing Modes

Two operands per instruction
Source/dest operand
Register
Register
Register
Memory
Memory

Second source operand
Register
Immediate
Memory
Register
Immediate
Memory addressing modes
 Address in register
 Address = Rbase + displacement
 Address = Rbase + 2scale × Rindex (scale = 0, 1, 2, or 3)
 Address = Rbase + 2scale × Rindex + displacement
Instruction Set-135
Computer Architecture
x86 Instruction Encoding

Variable length encoding
 Postfix bytes specify
addressing mode
 Prefix bytes modify
operation
 Operand length,
repetition, locking,
…
Instruction Set-136
Computer Architecture
Implementing IA-32


Complex instruction set makes implementation
difficult
 Hardware translates instructions to simpler
microoperations
 Simple instructions: 1–1
 Complex instructions: 1–many
 Microengine similar to RISC
 Market share makes this economically viable
Comparable performance to RISC
 Compilers avoid complex instructions
Instruction Set-137
Computer Architecture


Powerful instruction  higher performance
 Fewer instructions required
 But complex instructions are hard to implement
 May slow down all instructions, including simple
ones
 Compilers are good at making fast code from
simple instructions
Use assembly code for high performance
 But modern compilers are better at dealing with
modern processors
 More lines of code  more errors and less
productivity
Instruction Set-138
Computer Architecture
§2.18 Fallacies and Pitfalls
Fallacies
Fallacies

Backward compatibility  instruction set doesn’t
change
 But they do accrete more instructions
x86 instruction set
Instruction Set-139
Computer Architecture
Pitfalls


Sequential words are not at sequential addresses
 Increment by 4, not by 1!
Keeping a pointer to an automatic variable after
procedure returns
 e.g., passing pointer back via an argument
 Pointer becomes invalid when stack popped
Instruction Set-140
Computer Architecture
Concluding Remarks



Design principles
1.Simplicity favors regularity
2.Smaller is faster
3.Make the common case fast
4.Good design demands good compromises
Layers of software/hardware
 Compiler, assembler, hardware
MIPS: typical of RISC ISAs
 c.f. x86
Instruction Set-141
Computer Architecture
Concluding Remarks

Measure MIPS instruction executions in benchmark
programs
 Consider making the common case fast
 Consider compromises
Instruction class
MIPS examples
SPEC2006 Int
SPEC2006 FP
Arithmetic
Data transfer
add, sub, addi
lw, sw, lb, lbu,
lh, lhu, sb, lui
and, or, nor, andi,
ori, sll, srl
beq, bne, slt,
slti, sltiu
j, jr, jal
16%
35%
48%
36%
12%
4%
34%
8%
2%
0%
Logical
Cond. Branch
Jump
Instruction Set-142
Computer Architecture