Lecture 09 Recursion

More MIPS: Recursion

Computer Science 104 Lecture 9

2 © Andrew D. Hilton / Alvin R. Lebeck CPS 104

Homework • Homework 1: graded. 50% As, 27% Bs • Homework 2: Due Wed

Midterm 1 • This Wed • 1 page of notes

3 © Andrew D. Hilton / Alvin R. Lebeck

Last time…

What did we do last time?

CPS 104

Last time…

What did we do last time? • More MIPS! • Functions:

− jal − jr − Calling conventions − Stack Frames, saving registers

• Worked “bubble sort” example

CPS 104

0 zero constant 0

1 at reserved for assembler

2 v0 expression evaluation &

3 v1 function results

4 a0 arguments

8 t0 temporary: caller saves

16 s0 callee saves

24 t8 temporary (cont’d)

26 k0 reserved for OS kernel

28 gp Pointer to global area

29 sp Stack pointer

30 fp frame pointer

31 ra Return Address (HW)

Review: MIPS Registers

Review: Calling a function

Calling Procedure Step-1: Setup the arguments:

• The first four arguments (arg0-arg3) are passed in registers $a0-$a3 • Remaining arguments are pushed onto the stack (in reverse order arg5 is at the top of the stack).

Step-2: Save caller-saved registers • Save registers $t0-$t9 if they contain live values at the call site.

Step-3: Execute a jal instruction.

Review: Callee setup

Called Routine Step-1: Establish stack frame.

• Subtract the frame size from the stack pointer. addiu $sp, $sp, - <frame-size>

• Typically, minimum frame size is 32 bytes (8 words).

Step-2: Save callee saved registers in the frame.

• Register $fp is always saved. • Register $ra is saved if routine makes a call. • Registers $s0-$s7 are saved if they are used.

Step-3: Establish Frame pointer • Add the stack <frame size> - 4 to the address in $sp

addiu $fp, $sp, <frame-size> - 4

Review: Returning

On return from a call Step-1: Put returned values in registers $v0.

(if a value is returned) Step-2: Restore callee-saved registers.

• Restore $fp and other saved registers. [$ra, $s0 - $s7]

Step-3: Pop the stack • Add the frame size to $sp.

addiu $sp, $sp, <frame-size>

Step-4: Return • Jump to the address in $ra.

jr $ra

More MIPS! • Recursion

Won’t be required on the exam… • But you could use recursion if you want… • And good MIPSing practice anyways

Extra time? • I’ll work example problems, answer review

questions, etc…

CPS 104

Recursion

Why do we want recursion? • Because recursion is a wonderful thing!

Canonical recursion example? • Factorial

CPS 104

Factorial in C

int fact (int n) { if (n <= 0) {

return 1;

return n * fact (n – 1);

int x = fact(3);

CPS 104

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

factorial

n 1 return C1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

factorial

n 1 return C1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

factorial

n 1 return C1

factorial

n 0 return C1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

factorial

n 1 return C1

factorial

n 0 return C1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

factorial

n 1 return C1

fact returned 1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

factorial

n 2 return C1

fact returned 1

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

factorial

n 3 return C0

fact returned 2

Factorial in C

return 1;

int main (void) {

int x = fact(3);

CPS 104

Factorial in Assembly

return 1;

return n * fact (n – 1); }

int main (void) {

int x = fact(3);

CPS 104

Observe: Parameter n in $a0 Need to put n-1 in $a0 to call Need n after call

return 1;

int main (void) {

int x = fact(3);

CPS 104

Conclusion: Need to move n to other reg Which one: $t0 or $s0?

return 1;

int main (void) {

int x = fact(3);

CPS 104

Conclusion: Need to move n to other reg Which one: $t0 or $s0? Would need save/restore => May as well use $s0

Convert C to Assembly

return 1;

int main (void) {

int x = fact(3);

CPS 104

(We’ll switch to emacs For this part)

<<frame setup>>

move $s0, $a0

blez $s0, factEndZero

addi $a0, $a0, -1

jal fact

mul $v0, $v0, $s0

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

Reg Value $a0 0003 $s0 1234 $v0 ABCD $sp FF80 $fp FFCC $ra 4000

Addr Value FF7C FF78 FF74 FF70 FF6C FF68 FF64 FF60 FF5C FF58 FF54 FF50 FF4C FF48 FF44 FF40

<<Frame Setup>>

addiu $sp, $sp, -16

sw $fp, 0($sp)

sw $ra, 4($sp)

sw $s0, 8($sp)

addiu $fp, $sp, 12

CPS 104

<<Frame Setup>>

addiu $sp, $sp, -16

sw $fp, 0($sp)

sw $ra, 4($sp)

sw $s0, 8($sp)

addiu $fp, $sp, 12

CPS 104

<<Frame Setup>>

addiu $sp, $sp, -16

sw $fp, 0($sp)

sw $ra, 4($sp)

sw $s0, 8($sp)

addiu $fp, $sp, 12

CPS 104

Addr Value FF7C FF78 FF74 FF70 FFCC FF6C FF68 FF64 FF60 FF5C FF58 FF54 FF50 FF4C FF48 FF44 FF40

<<Frame Setup>>

addiu $sp, $sp, -16

sw $fp, 0($sp)

sw $ra, 4($sp)

sw $s0, 8($sp)

addiu $fp, $sp, 12

CPS 104

Addr Value FF7C FF78 FF74 4000 FF70 FFCC FF6C FF68 FF64 FF60 FF5C FF58 FF54 FF50 FF4C FF48 FF44 FF40

<<Frame Setup>>

addiu $sp, $sp, -16

sw $fp, 0($sp)

sw $ra, 4($sp)

sw $s0, 8($sp)

addiu $fp, $sp, 12

CPS 104

Addr Value FF7C FF78 1234 FF74 4000 FF70 FFCC FF6C FF68 FF64 FF60 FF5C FF58 FF54 FF50 FF4C FF48 FF44 FF40

<<Frame Setup>>

addiu $sp, $sp, -16

sw $fp, 0($sp)

sw $ra, 4($sp)

sw $s0, 8($sp)

addiu $fp, $sp, 12

CPS 104

Reg Value $a0 0003 $s0 1234 $v0 ABCD $sp FF70 $fp FF7C $ra 4000

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

jal fact

mul $v0, $v0, $s0

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

jal fact

mul $v0, $v0, $s0

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

jal fact

mul $v0, $v0, $s0

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

jal fact # Addr 1040 mul $v0, $v0, $s0

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

Addr Value FF7C FF78 1234 FF74 4000 FF70 FFCC FF6C FF68 0003 FF64 1044 FF60 FF7C FF5C FF58 FF54 FF50 FF4C FF48 FF44 FF40

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

Addr Value FF7C FF78 1234 FF74 4000 FF70 FFCC FF6C FF68 0003 FF64 1044 FF60 FF7C FF5C FF58 0002 FF54 1044 FF50 FF6C FF4C FF48 FF44 FF40

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

Addr Value FF7C FF78 1234 FF74 4000 FF70 FFCC FF6C FF68 0003 FF64 1044 FF60 FF7C FF5C FF58 0002 FF54 1044 FF50 FF6C FF4C FF48 0001 FF44 1044 FF40 FF5C

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

Reg Value $a0 0000 $s0 0000 $v0 0001 $sp FF40 $fp FF4C $ra 1044

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

Notice how $sp and $fp describe the callers frame now

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

Reg Value $a0 0000 $s0 1234 $v0 0006 $sp FF70 $fp FFCC $ra 4000

<<Frame Cleanup>>

lw $s0, 8($sp)

lw $ra, 4($sp)

lw $fp, 0($sp)

addiu $sp, $sp, 16

CPS 104

<<frame setup>>

move $s0, $a0

addi $a0, $a0, -1

factRet:

<<frame cleanup>>

jr $ra

factEndZero:

li $v0, 1

b factRet

CPS 104

li $a0, 3

jal fact

move $a0, $v0

CPS 104

Value returned in $v0 Stack /callee saves restored

Recursion De-mystified?

Recursion: • Assembly: not required on midterm1 • Generally good to know • Hopefully de-mystified? • P.S. Some languages only have recursion…

CPS 104

Other ISAs

We’ve been studying MIPS • x86: Intel, AMD—very common, kind of ugly

− Variable length insns (1-22 bytes) − Very complex insns − Not a load-store ISA (can do mem + reg -> mem)

• PowerPC—more like MIPS (“RISC”) − Has some not-so RISC things: load-with-update

• ARM • …

Good to know others exist, but our focus is MIPS

CPS 104

Remaining Time: Work Examples, Answer ?s

With any remaining time I’ll • Work examples (write C, asm, do binary math..) • Answer questions • Whatever….

CPS 104

Lecture 09 Recursion

Documents

Transcript of Lecture 09 Recursion

CS 126 Lecture P6: RecursionCS 126 Lecture P6: Recursion. CS126 7-1 Randy Wang Why Learn Recursion?

1 Storage Classes, Scope, and Recursion Lecture 6.

Recursion, Structures, and Lists · 30/09/04 AIPP Lecture 3: Recursion, Structures, and Lists 1 Recursion, Structures, and Lists Artificial Intelligence Programming in Prolog Lecturer:

RECURSION CITS1001. 2 Scope of this lecture Concept of recursion Simple examples of recursion.

CS212: DATASTRUCTURES Lecture 3: Recursion 1. Lecture Contents 2 The Concept of Recursion Why recursion? Factorial – A case study Content of a.

Lecture 18 recursion

Lecture 2 Basic Data Structures and Recursion Review.

Recursion Recursion Recursion Recursion Recursion Recursion Recursion Recursion Recursion

CSE 143 Lecture Slides - courses.cs.washington.edu · 2 Recursion •recursion: The definition of an operation in terms of itself. –Solving a problem using recursion depends on

Algorithms Lecture 1: Recursion Fa ’12

Lecture 6: Recursion: Definitions, Solving recursive equationsbbm205/Lectures/Lecture6.pdf · Lecture 6: Recursion: De nitions, Solving recursive equations Lecturer: Lale Özkahya

Lecture - 8 On Stacks, Recursion. Prepared by, Jesmin Akhter, Lecturer, IIT,JU Lecture Outline Quick sort Algorithm Recursion –Calculate n factorial –Fibonacci.

7 8 - Recursion · 2008-10-15 · recursion) to end recursion; otherwise infinite recursion Lecture 7 Object-Oriented Programming 6 Recursion • Recursion solves a problem by solving

CSE 143 Lecture 9 - courses.cs.washington.educourses.cs.washington.edu/.../09-recursion_1.pdf · 7/11/2011 · Recursion •Iteration: a programming technique in which you describe

Lecture 13: More Recursion: Memoization Introduction to ...tau-cs1001-py.wdfiles.com/local--files/lecture... · recursion" is highly convenient for writing code may lead to highly

Lecture 10 Recursion

Lecture 07 A First Look at Recursion

Recursion. Binary search example postponed to end of lecture.

Lecture 13 Recursion (4) - Munch!tau-cs1001-py.wdfiles.com/local--files/lecture-presentations-2020b/lec13.pdfLecture 13: Recursion (4) - Munch! Instructors: Elhanan Borenstein, Amir

Lecture 7 – Recursion recursion •Recursion can be … · •Sometimes procedures that would be tricky to write ... a function that computes the factorial ... trick with recursion