Lec19 Intro to Computer Engineering by Hsien-Hsin Sean Lee Georgia Tech -- Program Control

ECE2030
Introduction to Computer Engineering
Lecture 19: Program Control
Prof. Hsien-Hsin Sean LeeProf. Hsien-Hsin Sean Lee
School of Electrical and Computer EngineeringSchool of Electrical and Computer Engineering
Georgia TechGeorgia Tech

Program Execution on Processors
• How a program is executed on a processor?
• How instructions ordering are maintained?
• Are there times we need to change the flow
of a program?
• How to handle change of flow of a program?

Program Counter
• How a sequence of
instructions are fetched
and executed by a
computer?
• Program Counter (PC)
– A special register
– Provide the logical
ordering of a program
– Point to the address of
the instruction to be
executed
main:
la $8, array
lb $9, ($8)
lb $10, 1($8)
add $11, $9, $10
sb $11, ($8)
addiu $8, $8, 4
lh $9, ($8)
lhu $10, 2($8)
add $11, $9, $10
sh $11, ($8)
addiu $8, $8, 4
lw $9, ($8)
lw $10, 4($8)
sub $11, $9, $10
sw $11, ($8)
PC

Program Counter (Little Endian)
main:
la $8, array
lb $9, ($8)
lb $10, 1($8)
add $11, $9, $10
sb $11, ($8)
addiu $8, $8, 4
lh $9, ($8)
lhu $10, 2($8)
add $11, $9, $10
sh $11, ($8)
addiu $8, $8, 4
lw $9, ($8)
lw $10, 4($8)
sub $11, $9, $10
sw $11, ($8)
0x01
0x10
0x08
0x3c
PC
la $8, array
0x00
0x00
0x09
0x81
PC+4
lb $9, ($8)
0x01
0x00
0x0a
0x81
PC+8
lb $10, 1($8)
• Each MIPS instruction is 4-byte wide
0x20
0x58
0x2a
0x01
0x00
0x00
0x0b
0xa1
0x04
add $11,$9,$10
sb $11, ($8)
PC+12
PC+16
PC+20

Program Counter Control
32-bit PC Register
System clock +
432
32
32
2k
x32
INSTRUCTION
MEMORY
32
Data (i.e. instruction)
Instruction Register

Change of Flow Scenarios
• Our current defaultdefault modemode
– Program executed in sequentialsequential order
• When a program will break the sequential
property?
– Subroutine Call and Return
– Conditional Jump (with Test/Compare)
– Unconditional Jump
• MIPS R3000/4000 uses
– Unconditional absolute instruction addressing
– Conditional relative instruction addressing

Absolute Instruction Addressing
• The next PC address is given as an absolute
value
– PC address = <given address>
• Jump class examples
– J LABEL
– JAL LABEL
– JALR $r
– JR $r

Absolute Addressing Example
• Assume no delay slot
• J Label2J Label2
– Encoding:
•Label2=0x00400048
•J opcode= (000010)2
•Encoding=0x8100012
– Temp = <Label2 26-bit addr>
– PC = PC31..28|| Temp || 0
2
main:
la $8, array
lb $9, ($8)
lb $10, 1($8)
add $11, $9, $10
sb $11, ($8)
j Label2
...
...
Label2:
addiu $8, $8, 4
lh $9, ($8)
lhu $10, 2($8)

Relative Instruction Addressing
• An offset relative to the current PC address is
given instead of an absolute address
– PC address = <current PC address> + <offset>
• Branch class examples
– bne $src, $dest, LABEL
– beq $src, $dest, LABEL
– bgez $src, LABEL
– Bltz $src, LABEL
– Note that there is no blt instruction, that’s why slt
is needed. To facilitate the assembly programming,
there is a “bltblt pseudo oppseudo op”” that programmers can
use.

Relative Addressing Example
• Assume no delay slot
• beq $20,$22,L1beq $20,$22,L1
– Encoding=0x12960004 (next slide)
– Target=(offset15)
14
|| offset || 0
2
– PC = PC + Target
la $8, array
beq $20, $22, L1
lb $10, 1($8)
add $11, $9, $10
sb $11, ($8)
L1:
addiu $8, $8, 4

BEQ Encoding (I-Format)
beq $20, $22, L1
Offset Value
= (Target addr – beq addr)/4
= # of instructions in-between
including beq instruction
rt
rs
0 1 0 0 1 0 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 00 0
Encoding = 0x12960004
0 1 0 0 1 0 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 00 0
31
opcode rs rt
26 25 21 20 16 15 0
Offset Value
Branch to L1 if $20==$22
Offset = 4
instructions

Relative Addressing Example
• The offset can be positive as well as negative
L2:
addiu $20, $22, 4
lw $24, ($22)
lw $23, ($20)
beq $24, $23, L2
0 1 0 0 1 1 0 0 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 10 0
Encoding = 0x1317FFFD
0 1 0 0 1 1 0 0 0 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 10 0
31
opcode rs rt
26 25 21 20 16 15 0
Offset Value
Offset = -3-3
instructions
beq $24, $23, L2

MIPS Control Code Example
• See array.s and prime.s

Procedural Calls in MIPS
• MIPS uses jal or jalr to perform procedure calls
(assume no branch delay slot)
– jal LABEL # r31 = PC + 4
– jal rd, rs # rd = PC + 4
• Return address is automatically saved
• When return from procedure
– jr $31 or jr $d
– Note that $31 is aliased to $ra
• Call convention
– Use $a0 to $a3 ($4 to $7) for the first 4 arguments
– Use $v0 ($2) for passing the result back to the caller

Procedural Call Example
C code snippetC code snippet
z = pyth(x, y);
z = sqrt(z);
int
pyth(int x, int y)
{
return(x2
+y2
);
}
MIPS snippetMIPS snippet
la $t0, x
la $t1, y
lw $a0, ($t0)
lw $a1, ($t1)
jal pyth
add $a0, $v0, $zero
jal sqrt
la $t2, z
sw $v0, ($t2)
pyth:
mult $a0, $a0
mflo $t0
mult $a1, $a1
mflo $t1
add $v0, $t0, $t1
jr $ra
sqrt:
….
jr $raNote that by software convention,
$t0 to $t7 are called “caller-saved” registers,
i.e. the caller is responsible to back them up
before procedure call if they are to be used
after the procedure call again

Procedural Call: Recursion
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
return(n * fact(n-1))
}
la $t0, x
lw $a0, ($t0)
jal fact
fact:
addi $v0, $zero, 1
blt $a0, $v0, L1
addi $a0, $a0, -1
jal fact
L1:
jr $ra
?
$ra ($31) is overwritten and old value is lost

Procedural Call: Many Arguments
long a[5];
z = foo(a[0], a[1], a[2],
a[3], a[4]);
int foo(int t, int u,
int v, int w,
int x)
{
return(t+u-v*w+x);
}
la $t0, a
lw $a0, 0($t0)
lw $a1, 4($t0)
lw $a2, 8($t0)
lw $a3, 12($t0)
lw ???, 16($t0)
foo:
...
...
jr $ra
Run out of passing argument registers !

Stack
• The solution to address the prior 2 problems
• a LIFO (Last-In First-Out) memory
• A scratch memory space
• Typically grow downward (i.e. push to lower address)

Stack
• Stack Frame
– Base pointed by a special register $sp (=$29)
– Each procedure has its own stack frame (if stack space is
allocated)
• Push
– Allocate a new stack frame when entering a procedure
– subu $sp, $sp, 32
– What to store?
• Return address
• Additional passing arguments
• Local variables
• Pop
– Deallocate the stack frame when return from procedure
– addu $sp, $sp, 32

Stack Push
4 bytes
higher
addr
lower
addr
$sp
jal foo
...
...
foo:
subu $sp, $sp, 32
...
addu $sp, $sp, 32
jr $ra
PUSHPUSH
NewStackFrameNewStackFrame
forfoo()forfoo()

Stack Pop
4 bytes
higher
addr
lower
addr
$sp
jal foo
...
...
foo:
subu $sp, $sp, 32
...
addu $sp, $sp, 32
jr $ra
NewStackFrameNewStackFrame
forfoo()forfoo()
CurrentCurrent
StackStack
FrameFrame

Recursive Call
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
}
li $v0, 1
j fact
fact:
beq $a0, $v0, return
return:
jr $ra

Recursive Call
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
}
li $v0, 1
j fact
fact:
jal fact
return:
jr $ra
What to do with
$a0 and $ra ?

Push onto the Stack
li $v0, 1
j fact
fact:
sub $sp, $sp, 8
sw $ra, 4($sp)
sw $a0, 0($sp)
sub $a0, $a0, 1
jal fact
return:
jr $ra
$sp
Return address
$a0 (= X)
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
}
What happens
after returning from
the procedure ???

Pop from the Stack
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
}
li $v0, 1
j fact
fact:
sub $sp, $sp, 8
sw $ra, 4($sp)
sw $a0, 0($sp)
sub $a0, $a0, 1
jal fact
lw $a0, 0($sp)
lw $ra, 4($sp)
mult $a0, $v0
mflo $v0
add $sp, $sp, 8
return:
jr $ra$sp
Return address
$a0 (= X)

Recursive call for Factorial
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
}
li $v0, 1
j fact
fact:
sub $sp, $sp, 8
sw $ra, 4($sp)
sw $a0, 0($sp)
sub $a0, $a0, 1
jal fact
lw $a0, 0($sp)
lw $ra, 4($sp)
mult $a0, $v0
mflo $v0
add $sp, $sp, 8
return:
jr $ra

Lec19 Intro to Computer Engineering by Hsien-Hsin Sean Lee Georgia Tech -- Program Control

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Lec19 Intro to Computer Engineering by Hsien-Hsin Sean Lee Georgia Tech -- Program Control (20)

Recently uploaded (20)

Lec19 Intro to Computer Engineering by Hsien-Hsin Sean Lee Georgia Tech -- Program Control