Bonus Lecture: Fibonacci

Transcription

1 Bonus Lecture: Fibonacci ECE Rick

2 Reading You could try looking up recurisve function in your textbook.

3 Recursive Fibonacci if (x < 2) return fibonacci(x 1) + fibonacci(x - 2); Every recursive function has a terminating condition and a recurrence. (This one has two recurrences.) Let s rewrite this for just a little clarity in explanation.

4 Recursive Fibonacci if (x < 2) Every recursive function has a terminating condition and a recurrence. (This one has two recurrences.) The question is, what do we need to save across invocations of the recurrence? We wouldn t need to save anything for the first recurrence. However, it overwrites x which we need for the second recurrence. It also produces a partial sum that we need to save before the second recurrence.

5 Two ways to implement (1) We can save the variables by allocating space on the stack for them. (2) We can save the data by pushing two registers and saving the variables in the pushed registers.

6 Stack allocation method.global fibonacci push {lr pop {pc LR We need to branch to recursion if x >= 2, and this should be an unsigned comparison, but there is no unsigned >=. There is, however, a branch for an unsigned > (bhi). Saying x >= 2 is the same as saying x > 1. Here is the non-recursive part of the subroutine.

7 Stack allocation method.global fibonacci push {lr pop {pc sub sp, #8 LR (sum) (x) Next, we allocate two words of space on the stack for the two variables we want to save by decrementing by 8. We arbitrarily choose the one pointed to by to hold x, and the next one to hold sum. Down below, we remember that we must undo the reservation with an add sp, #8 before we pop the old LR. add sp, #8 pop {pc

8 Stack allocation method Next, we save X (r0) to the right place in our subroutine s stack frame. We set up r0 with x-1. We call fibonacci (which will also allocate/deallocate new stack space). The recursive call to fibonacci will overwrite LR with the address of the next instruction..global fibonacci LR push {lr (sum) (x) pop {pc sub sp, #8 str r0, [sp,#0] // save x subs r0, #1 // x - 1 add sp, #8 pop {pc

9 Stack allocation method Next, we store the result of the recursive call to the space on the stack. We reload x, subtract 2, and make the second recursive call..global fibonacci LR push {lr (sum) (x) pop {pc sub sp, #8 str r0, [sp,#0] // save x subs r0, #1 // x-1 str r0, [sp,#4] // save sum ldr r0, [sp,#0] // load x subs r0, #2 // x-2 add sp, #8 pop {pc

10 Stack allocation method Next, we reload the partial sum from the first recursion into r1, add it to the result of the second recursion (in r0), and we re done. The result is in r0. We deallocate the two words on the stack, pop the PC, and we re out..global fibonacci LR push {lr (sum) (x) pop {pc sub sp, #8 str r0, [sp,#0] // save x subs r0, #1 // x-1 str r0, [sp,#4] // save sum ldr r0, [sp,#0] // load x subs r0, #2 // x-2 ldr r1, [sp,#4] // load sum adds r0, r1 // r0 += sum add sp, #8 pop {pc

11 Stack allocation method After returning, the old things we put on the stack are still there, but has been reincremented to point back to where it was before fibonacci was called..global fibonacci LR push {lr (sum) (x) pop {pc sub sp, #8 str r0, [sp,#0] // save x subs r0, #1 // x-1 str r0, [sp,#4] // save sum ldr r0, [sp,#0] // load x subs r0, #2 // x-2 ldr r1, [sp,#4] // load sum adds r0, r1 // r0 += sum add sp, #8 pop {pc

12 Things to remember: Each recursive call to fibonacci will either take or not take the branch. not taken: Only the LR is pushed to the stack, and is popped back into the PC. taken: The LR is pushed to the stack, then two more words are allocated. These allocations are undone before returning. Further recursive calls will also add things of their own to the stack (their own LR and 2 extra words), but they will restore the stack pointer to the same way it was when before the recursive call was made.

13 Register save method:.global fibonacci push {r4,r5,lr pop {r4,r5,pc LR R5 R4 We use the bhi instruction as before, but we know we ll need to save two words across recursion. This time, save them in registers. We must restore registers r4-r11 to be the way they were before the call. To do that, we save them now. Here is the non-recursive part of the subroutine.

14 Register save method: We arbitrarily decide to save X in r4 and save the sum in r5. These were saved by push, so we re free to use them in this subroutine. We compute x-1 and recurse..global fibonacci LR push {r4,r5,lr R5 R4 pop {r4,r5,pc movs r4,r0 // save x subs r0,#1 // x-1

15 Register save method: Next, we return from the recursive call to fibonacci and save the sum. We load x-2 into r0 and make the second recursive call..global fibonacci LR push {r4,r5,lr R5 R4 pop {r4,r5,pc movs r4,r0 // save x subs r0,#1 // x-1 mov r5,r0 // save sum subs r0,r4,#2 // x-2

16 Register save method: Next, we return from the 2 nd recursive call to fibonacci and add the old sum to the new result. We load x-2 into r0 and make the second recursive call. And we re done. R0 holds the result..global fibonacci LR push {r4,r5,lr R5 R4 pop {r4,r5,pc movs r4,r0 // save x subs r0,#1 // x-1 mov r5,r0 // save sum subs r0,r4,#2 // x-2 adds r0,r5 // r0 += sum pop {r4,r5,pc

17 Register save method: After returning, the old values are still in the stack memory, but the has been incremented and no longer points to the old stack frame. Any subsequent subroutine will overwrite the old stack contents..global fibonacci LR push {r4,r5,lr R5 R4 pop {r4,r5,pc movs r4,r0 // save x subs r0,#1 // x-1 mov r5,r0 // save sum subs r0,r4,#2 // x-2 adds r0,r5 // r0 += sum pop {r4,r5,pc

18 Things to remember: The call to fibonacci that we showed might have been the first call from main, or it might have been the 30 th -level recursive call from an initial call of fibonacci(30) from main(). There is no meaningful difference. Each subroutine reserves its own chunk of stack called its stack frame. The stack frame is always accessed relative to the current register.