CS255 Syllabus

Second Recursive Function: Fibonnaci

2nd recursion example: Fibonnaci

The Fibonacci function can be written in a high level programming language as follows:

int fib(int n) { if (n == 0) return(1); <--- easy case 1 else if (n == 1) return(1); <--- easy case 2 else { return( fib(n-1) + fib(n-2) ); <--- Return the solution for fib(n) } } main( ) { int result, k; result = fib(k); }

Since the parameter of the Fibonacci function is n, I will use n to refer to this parameter variable in this webpage.

Notice that:

main( ) calls the fib(k) method

main( ) must pass the variable k using the program stack !!!
(And the value of this variable k is refered to by the variable name n inside the Fibonacci method !!!)

fib( ) also calls the fib( ) method, not just once but twice -- with different parameters (see: fib(n-1) and fib(n-2))

When fib(n) calls fib(n-1), fib(n) must pass the parameter (n-1) using the program stack !!!
When fib(n) calls fib(n-2), fib(n) must pass the parameter (n-2) using the program stack !!!

Important observation in the Fibonacci method

Very important note:

There are multiple function calls in the following expression in the Fibonacci method:
The addition fib(n-1) + fib(n-2) must make 2 separate function calls to compute:
After fib(n-1) returns we cannot perform the addition; but must make a function call to compute fib(n-2) !!!
Therefore:

We have learned:

We must save important values in registers when we make a call to a method
(Because the method can change any registers and we may lose the important values if we don't save them !!!)

We have also learned how to save registers on the program stack to solve this interrupted computation problem.

We will need to use that technique when we write the Fibonacci function !!!

If you need to review the solution, visit this webpage: click here

Calling the Fibonnaci method
- From the fact that you must pass parameters of a recursive method using the program stack and the fact that fib( ) has a parameter n, this is how you must call fib( ):

The stack frame structure for the Fibonacci function

The stack frame structure that you need to create will depend on:
In the fib( ) method above, we see that the Fibonacci function has

The stack frame structure created (and used by fib( ) will therefore be as follows:

You can see that the fib( ) function will:

Access the parameter variable (n) using offset 8 from the frame pointer FP

The main( ) call to fib( )

Here is the assembler code for the main( ) function that calls fib( ) with the value in the variable N:

main: // High level programming statement: // // result = fib(k) /* ------------------------------------------------- Pass parameter k (using stack) ------------------------------------------------- */ movw r0, #:lower16:k movt r0, #:upper16:k ldr r0, [r0] // r0 = k push {r0} // Pass k using the program stack /* ------------------------------------------------------ call result = fib(k) ------------------------------------------------------ */ bl fib add sp, sp, #4 // Clean up the parameter k /* ----------------------------------------------------------------- Save return value (in r0) to variable result ----------------------------------------------------------------- */ movw r1, #:lower16:result // Do NOT use r0 !!! movt r1, #:upper16:result // (Because r0 contains the return value) str r0, [r1] // This will store return value in sum

The Fibonacci recursive method/function

The Fibonacci method in assembler:

/* ---------------------------------------------------------------- Function int fib(int n) Stack frame structure: old FP <--------------------------------- FP old LR (ret addr) n +8 Body of fib(n) if ( n == 0 ) return 1; if ( n == 1 ) return 1; else return ( fib(n-1) + fib(n-2) ); ---------------------------------------------------------------- */ fib: // When fib begins, we will have: parameter n on the stack /* ========================================================== Function Prelude: complete the stack frame structure ========================================================== */ push {lr} // Save LR (return address) push {fp} // Save FP (used by caller) mov fp, sp // Mark the stack top location before // allocating any local variables sub sp, sp, #0 // Allocate 0 int variables on the stack // (I could omit this instruction....) /* =============================================== We have completed the stack frame Now we can write the function body =============================================== */ // if ( n == 0 ) ldr r0, [fp, #8] // r0 = n cmp r0, #0 // Check n == 0 bne else1 // n != 0 --> Goto "else1" part // return 1 ///// put return value 1 in return location r0 mov r0, #1 /* ============================================================= Function Postlude: de-allocate local variable and restore FP ============================================================= */ mov sp, fp // De-allocate local variables pop {fp} // Restore fp pop {pc} // Return to the caller else1: // if ( n == 1 ) ldr r0, [fp, #8] // r0 = n cmp r0, #1 // Check n == 1 bne else1 // n != 1 --> Goto "else2" part // return 1 ///// put return value 1 in return location r0 mov r0, #1 /* ============================================================= Function Postlude: de-allocate local variable and restore FP ============================================================= */ mov sp, fp // De-allocate local variables pop {fp} // Restore fp pop {pc} // Return to the caller else2: // Compute: fib(n-1) + fib(n-2) //// Compute fib(n-1) first ldr r0, [fp, #8] // r0 = n sub r0, r0, #1 // r0 = n-1 push {r0} // pass (n-1) to fib on stack bl fib // Calls: fib( ) with parameter = (n-1) !!! add sp, sp, #4 // Clean up parameter (n-1) from stack //// ** Right now, r0 = fib(n-1) --- we can't lose this value !!! //// ** But we can't compute fib(n-1) + fib(n-2) without fib(n-2) //// ** We will call fib to compute fib(n-2) //// ** We MUST save r0 on the STACK !!! push {r0} // Save fib(n-1) on the stack //// Compute fib(n-2) ldr r0, [fp, #8] // r0 = n sub r0, r0, #2 // r0 = n-2 push {r0} // pass (n-2) to fib on stack bl fib add sp, sp, #4 // Clean up parameter (n-2) from stack //// ** Right now, r0 = fib(n-2) - we can now compute fib(n-1)+fib(n-2) pop {r1} // Retrieve fib(n-1) from the stack add r0, r1, r0 // r0 = fib(n-1) + fib(n-2) // NOTE: r0 has the correct return value !!! // return fib(n-1)+fib(n-2) in r0 /* ============================================================= Function Postlude: de-allocate local variable and restore FP ============================================================= */ mov sp, fp // De-allocate local variables pop {fp} // Restore fp pop {pc} // Return to the caller

Example Program: (Demo above code)
- Prog file: /home/cs255001/demo/asm/8-sub/fib.s
How to run the program:
I will highlight certain steps in the program in the remainder of the webpage....

Highlights important steps in the fib function

Passing the parameter k from main program to fib

The main program passes the variable k to the Fibonacci method by pushing the value of variable k onto the system stack with the following instruction:

movw r0, #:lower16:k movt r0, #:upper16:k ldr r0, [r0] // Now: r0 = k push {r0} // Pass k using the program stack

This will create the following stack structure:

+---------------------+ <------------ Stack pointer (SP) | parameter n(= k) | +---------------------+

Main program calling the fib function
The main program calls the Fibonacci function with a bl instruction:
This will save the return address to main( ) in the LR register and jump to the fib method
The fib( ) function will start running, so let's take a look at the fib( ) function

Prelude of the Factorial function:

The prelude of the Fibonacci function consists of these instructions:

/* ========================================================== Function Prelude: complete the stack frame structure ========================================================== */ push {lr} // Save LR (return address) push {fp} // Save FP (used by caller) mov fp, sp // Mark the stack top location before // allocating any local variables sub sp, sp, #0 // Allocate 0 int variables on the stack // (I could omit this instruction....)

I will explain what each one does below.

Make sure that you realise that the structure of the stack frame is like this when the prelude of the fib( ) method is executed:

+---------------------+ <------------ Stack pointer (SP) | parameter n | +---------------------+

push {lr}

This instruction will save the return address in the LR register on the program stack.

The program stack now looks like this:

+---------------------+ <------------ Stack pointer (SP) | return address | +---------------------+ | parameter n | +---------------------+

push {fp}

This will save the frame pointer on the stack and the program stack now looks like this:

+---------------------+ <------------ Stack pointer (SP) | old Frame Pointer | +---------------------+ | return address | +---------------------+ | parameter n | +---------------------+

mov fp,sp

This will make the frame pointer FP points to the stack frame that is being built:

The will enable the fib( ) to use offset from the frame pointer to access the parameters and local variables that are stored in the program stack

sub sp,sp,#0

The subtract instruction is used to allocate local variables on the program stack

But since fib( ) has no local variables, this instruction does nothing to the stack pointer SP... (and we could omit it - I left it in to keep the discussion uniform)

We have now completed the stack frame:

When the prelude is finish, the stack frame is complete and the actual function can begin.

How to access the parameter n in the fib function:
- Parameter n is located 8 bytes (old Frame Pointer is 4 bytes and return address is 4 bytes) below the location pointed to by frame pointer FP.
  So the base register (FP) + offset 8 will let you access this variable
  That's why you see the use of the instruction ldr r1, [fp,#8] in fib( ) to get the parameter:

How fib(n) calls fib(n-1):

It is no different from how the main program calls the Fibonacci function.

The Fibonacci method can call the Fibonacci method by passing the parameter on the program stack and then use bl fib to call the Fibonacci method.

But make sure you pop the parameter from the stack after the Fibonacci function returns - because the parameter has not been cleaned up.

The following is the program fragment where Fibonacci calls fib(n-1):

ldr r0, [fp, #8] // r0 = n sub r0, r0, #1 // r0 = n-1 push {r0} // pass (n-1) to fib on stack bl fib // Calls: fib( ) with parameter = (n-1) !!! add sp, sp, #4 // Clean up parameter (n-1) from stack

Saving the fib(n-1) result before calling fib(n-2)
This is done by pushing r0 on to the program stack:

How fib(n) calls fib(n-2):

The Fibonacci method can call the Fibonacci method by passing the value n-2 on the program stack and then use bl fib to call the Fibonacci method.

But make sure you pop the parameter from the stack after the Fibonacci function returns - because the parameter has not been cleaned up.

The following is the program fragment where Fibonacci calls fib(n-1):

ldr r0, [fp, #8] // r0 = n sub r0, r0, #2 // r0 = n-2 push {r0} // pass (n-1) to fib on stack bl fib // Calls: fib( ) with parameter = (n-1) !!! add sp, sp, #4 // Clean up parameter (n-1) from stack

Retrieving the saved fib(n-1) result after calling fib(n-2) to continue the computation.
This is done by popping the top of the stack in register r1 (because register r0 contains fib(n-2)):