The document discusses program control in computer engineering. It describes how a program counter (PC) controls instruction execution by incrementing to the next instruction address after each execution. The PC can be modified to change the normal sequential execution flow through mechanisms like jumps, branches, and subroutine calls and returns. Subroutines use a stack to save registers and pass arguments. Recursive subroutines additionally push the calling address and argument onto the stack to preserve their values across recursive activations.

1. 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

2. 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?

3. 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

4. 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

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

6. 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

7. 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

8. 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)

9. 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.

10. 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

11. 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

12. 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

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

14. 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

15. 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

16. Procedural Call: Recursion
C code snippetC code snippet
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
return(n * fact(n-1))
}
MIPS snippetMIPS snippet
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

17. Procedural Call: Many Arguments
C code snippetC code snippet
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);
}
MIPS snippetMIPS snippet
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 !

18. 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)

19. 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

20. 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()

21. 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

22. Recursive Call
C code snippetC code snippet
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
return(n * fact(n-1))
}
MIPS snippetMIPS snippet
li $v0, 1
j fact
fact:
beq $a0, $v0, return
return:
jr $ra

23. Recursive Call
C code snippetC code snippet
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
return(n * fact(n-1))
}
MIPS snippetMIPS snippet
li $v0, 1
j fact
fact:
beq $a0, $v0, return
jal fact
return:
jr $ra
What to do with
$a0 and $ra ?

24. Push onto the Stack
MIPS snippetMIPS snippet
li $v0, 1
j fact
fact:
beq $a0, $v0, return
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)
C code snippetC code snippet
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
return(n * fact(n-1))
}
What happens
after returning from
the procedure ???

25. Pop from the Stack
C code snippetC code snippet
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
return(n * fact(n-1))
}
MIPS snippetMIPS snippet
li $v0, 1
j fact
fact:
beq $a0, $v0, return
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)

26. Recursive call for Factorial
C code snippetC code snippet
z = fact(x);
int fact(int n)
{
if (n < 1)
return(1);
else
return(n * fact(n-1))
}
MIPS snippetMIPS snippet
li $v0, 1
j fact
fact:
beq $a0, $v0, return
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