CS255 Syllabus

Second Recursive Function: Fibonacci

Again, I want to show you more than just implementing the Fibonacci function in assembler.
Here is my CS170 webpage that explain what Fibonacci was doing when he formulated the equation for Fibonacci number: click here

The Fibonacci function

The Fibonacci function can be written explicitly as follows:

 int fib(int n)
 { int help1, help2;
   if (n = 0)
      return 1;
   else if (n == 1)
      return 1;
   else
    { help1 = fib(n-1);      
      help2 = fib(n-2);
      return help1+help2;
    }
 }

The Fibonacci function is called with a statement that is similar to the factorial one:
```
   int n, result;

   result = fib(n);
```

The stack frame structure for the Fibonacci function

The stack frame structure created will looks as follows:

   +---------------------+ <------------ Stack pointer (A7)
   |   use for help2 var |
   +---------------------+
   |   use for help1 var |
   +---------------------+ <------------ Frame Pointer (A6)
   | Saved Frame Pointer |
   +---------------------+
   |  Return Address     |
   +---------------------+
   | use for parameter n |
   +---------------------+
   |     .......         |
   |  rest of the stack  |
   |     .......         |

The Fibonacci program:
- The complete example can be found in the following assembler program file: click here
- You may want to get the following Debug file for EGTAPI to use with it: click here
- I will highlight certain steps in the program in the remainder of the webpage....

Passing parameter n from main program to fib

The main program passes the parameter n to Fibonacci by pushing n onto the system stack with the following instruction:

    move.l n, -(a7)

This will create the following stack structure:

   +---------------------+ <------------ Stack pointer (A7)
   |     parameter n     |
   +---------------------+
   |     .......         |
   |  rest of the stack  |
   |     .......         |

Main program calling fib function

The main program calls the Fibonacci function with a bsr instruction:

    bsr  fib

This will create the following stack structure:

   +---------------------+ <------------ Stack pointer (A7)
   |     return address  |
   +---------------------+
   |     parameter n     |
   +---------------------+
   |     .......         |
   |  rest of the stack  |
   |     .......         |

Prelude of the Factorial function:

The prelude of the Fibonacci function consists of these 3 instructions:

********************************* PRELUDE
        move.l a6, -(a7)    ; Save caller's frame pointer
        move.l a7, a6       ; Setup my own frame pointer
        suba.l #8, a7       ; Allocate space for help1 & help2
*********************************

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 is always executed:

   +---------------------+ <------------ Stack pointer (A7)
   |     return address  |
   +---------------------+
   |     parameter n     |
   +---------------------+
   |     .......         |
   |  rest of the stack  |
   |     .......         |

move.l a6, -(a7)

This will save the frame pointer on the stack, creating this partial stack frame structure:

   +---------------------+ <------------ Stack pointer (A7)
   |     saved a6        |
   +---------------------+
   |     return address  |
   +---------------------+
   |     parameter n     |
   +---------------------+
   |     .......         |
   |  rest of the stack  |
   |     .......         |

move.l a7, a6

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

   +---------------------+ <---- Frame pointer A6 & Stack pointer (A7)
   |     saved a6        |       point to the same location....
   +---------------------+
   |     return address  |
   +---------------------+
   |     parameter n     |
   +---------------------+
   |     .......         |
   |  rest of the stack  |
   |     .......         |

suba.l #8, a7

This will push the stack pointer A7 8 bytes up, allocating 2 integer variables. How these variables will be used is upto the discretion of the programmer. In the program, I will use the lower one for help1 and the upper one for help2.

   +---------------------+ <---- Stack pointer (A7)
   |     help2           |
   +---------------------+
   |     help1           |
   +---------------------+ <---- Frame pointer (A6)
   |     saved a6        |
   +---------------------+
   |     return address  |
   +---------------------+
   |     parameter n     |
   +---------------------+
   |     .......         |
   |  rest of the stack  |
   |     .......         |

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

How to access the parameter and the local variables in fib:
- Parameter n is located 8 bytes below starting from the address contained in the frame pointer A6.
  So the address mode that will let you get to this variable is 8(A6)
- Local variable Sol is located 4 bytes above starting from the address contained in the frame pointer A6.
  So the address mode that will let you get to this variable is -4(A6)
- Local variable SolX is located 8 bytes above starting from the address contained in the frame pointer A6.
  So the address mode that will let you get to this variable is -8(A6)
- Use the above way to gain access to you own private copy of parameters and local variables....

How Fibonacci calls itself:

It is no different from how the main program calls the Fibonacci function. Simply push the parameter on the stack, and call Fibonacci.

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

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

       move.l 8(a6), d0    ; retrieve parameter n into register d0
       sub.l #1, d0        ; d0 = n - 1
*
* ----------------------------- ; fib is calling fib now !!!!
*
        move.l d0, -(a7)    ; Push (n-1) as parameter
        bsr    fib          ; Call fib(n-1)
        adda.l #4,a7        ; Clean up parameter from stack

        move.l d0, -4(a6)   ; help1 = return value of fib(n-1) in register D0

Fibonacci will call itself a second time with value n-2. The following is the program fragment where Fibonacci calls fib(n-2):

       move.l 8(a6), d0    ; retrieve parameter n into register d0
       sub.l #2, d0        ; d0 = n - 2
*
* ----------------------------- ; fib is calling fib again....
*
        move.l d0, -(a7)    ; Push (n-2) as parameter
        bsr    fib          ; Call fib(n-2)
        adda.l #4,a7        ; Clean up parameter from stack

        move.l d0, -8(a6)   ; help2 = return value of fib(n-1) in register D0

I have highlighted the difference between the first call and the second. The second call uses a different parameter value and stores the return value in a different local variable !