CS255 Syllabus

Writing recursive functions in assembler code

There is absolutely no need to handle any statements (if, if-else, while, for, etc) differently in a recursive function/method.
The only difficulty when you write a recursive function/method is the fact that because recursive functions will call itself, there will be multiple activations of the same function... consequently:
- there are multiple copies of the parameter variables - one copy for each active function
- there are multiple copies of the local variables - also one copy for each active function
In fact, the only thing that we must do to implement recursion function is to design an access mechanism so that each active function has its own copy of parameter & local variables
This translates into the following problem that you have to solve to make a function/method recursive:
- How to "create" new parameter and local variables each time a function is invoked ?
  (i.e., how to create the parameter variables and local variables for a function when it is invoked)
- How to associate the multiple copies of the parameter & local variables with the multiple active invocations of the recursive function
  (i.e., how to make sure that each function invocation accesses it's own copy of the parameter and local variables and not those that belong to a different invacation...
- How to "destroy" the parameter and local variables when the function invocation is finished
  "Destroy" = reclaim - i.e., mark the memory space as "unused"
  (You need to do this or else the computer will run out of "free" (unused) memory space...)
Because the parameter and local variables are created and destroyed in the order of function activation/deactivation, it is natural to use the program stack

How to create parameter variables and local variables using the program stack:

 Before creating a variable:       After creating a variable on stack:

                    +----------+   Top of stack --> +----------+
                    |          |                    | new var  |
 Top of stack -->   +----------+                    +----------+
                    |  xxxxx   |                    |  xxxxx   |
                    +----------+                    +----------+

Before creating a new variable, the portion of memory above the "top of stack" was not reserved.

After creating a new variable, that portion of memory has become reserved.

The recursive routine will create parameters and local variables on the stack.

In fact: each invocation of a recursive routine will create its own set of parameters and local variables.

The stack looks like this when a recursive fac routine is called:

 Suppose main calls fac(3):

 Top of stack --> +----------------------+
                  |  local variables     |
		  |    +                 |
		  |  return address      | <--- fac(1) calls fac(0)
		  |    +		 |      and creates local vars
		  |  parameter variables |	+ parameters for fac(0)
		  |   (n = 0)		 |
                  +----------------------+
                  |  local variables     |
		  |    +                 |
		  |  return address      | <--- fac(2) calls fac(1)
		  |    +		 |      and creates local vars
		  |  parameter variables |	+ parameters for fac(1)
		  |   (n = 1)		 |
                  +----------------------+
                  |  local variables     |
		  |    +                 |
		  |  return address      | <--- fac(3) calls fac(2)
		  |    +		 |      and creates local vars
		  |  parameter variables |	+ parameters for fac(2)
		  |   (n = 2)		 |
                  +----------------------+
                  |  local variables     |
		  |    +                 |
		  |  return address      | <--- main calls fac(3)
		  |    +		 |      and creates local vars
		  |  parameter variables |      + parameters for fac(3)
		  |   (n = 3)		 |
                  +----------------------+

Very important question: what does the stack look like exactly (need to know this to do programming)

To answer the above question, we must take a close look at the order of events in a function call to see why the "things" stored on the stack is in a certain order.
Take a look at this call:
```
 main()
 {
    int r, n;

    r = fac(n);
 }
 
```
When main() calls fac(n), the following events happens in this order:
1. main passes n (somewhere) before branching to fac !
2. main executes BSR fac: push return address on stack and branches to fac
3. after a long while, fac returns (eventually). It will (if all things goes well) back to the instruction after BSR fac. At that moment, main can update r with the return value from fac (stored in an agreed location by fac that main can get to, usually is a register...)
Since in recursion, we must create new copies of parameter variables and we can create new variables using a stack (as discussed above), therefore, the steps above will translate into:
1. main pushes n on the stack before branching to fac !
2. main executes BSR fac: push return address on stack and branches to fac
3. when fac returns with the return value in some register, main stores the return value away.
If you observe the execution order, you will see that the stack will look like this when fac begins execution:
```
 Stack when fac starts executing:


 Top of stack --> +----------+
                  |  retaddr | <- retaddr pushed when main calls fac
                  +----------+
                  |    n     | <- main pushes parameter n first
                  +----------+
                  |  xxxxx   |
                  +----------+
 
```

Now fac starts and creates its own local variables on the stack. So the stack will look like this when a recursive function finally starts executing the body of the function:

 Top of stack --> +-------------+
                  | local vars  | <- fac allocates local vars
                  +-------------+
                  |  retaddr    | <- retaddr pushed when main calls fac
                  +-------------+
                  |    n        | <- main pushes parameter n first
                  +-------------+
                  |  xxxxx      |
                  +-------------+

This structure is called a stack frame

The above stack structure is the minimal structure that is necessary to create new parameters and local variables for each (recursive) function invocation, but it is not the most convenient

We still need to make it easy for us to access the variables.

If you take a look at a whole sequence of fac calls:

 Top of stack --> +-------------+
                  | local vars  | <--+
                  +-------------+    | (stack frame of fac(3))
                  |  retaddr    |    | parameters & local vars
                  +-------------+    | of fac(3)
                  |    n = 3    | <--+
                  +-------------+
                  | local vars  | <--+
                  +-------------+    | (stack frame of fac(4))
                  |  retaddr    |    | parameters & local vars
                  +-------------+    | of fac(4)
                  |    n = 4    | <--+
                  +-------------+
                  | local vars  | <--+
                  +-------------+    | (stack frame of fac(5))
                  |  retaddr    |    | parameters & local vars
                  +-------------+    | of fac(5)
                  |    n = 5    | <--+
                  +-------------+

How do you find your own variables easily ?

The technique that Computer Science researchers have developed over the years is to use a register as a fixed pointer to locate the variables of the currently active function.
The registers used in M68000 is usually A6 (since A7 is already used for stack pointer) to point to the stack frame. This register is called the (stack) frame pointer (fp)
Since A6 is shared between the different recursive function calls, A6 will then contain different values when a different recursive function is active. In other words, when fac(5) is active, A6 will have a certain value. When fac(5) calls fac(4), A6 will have a different value when it is running fac(4). Now, when fac(4) (eventually) returns to fac(5), the A6 value used by fac(5) must be restored ! (remember that fac(4) uses a different value for A6.
Pictorially:
```
      fac(5)			      +----> fac(4)
        |			      |        |
        | A6 points to		      |        | A6 points to
        | fac(5)'s parameters	      |        | fac(4)'s param
        | and local variables	      |        | and local vars
        |			      |        |
        +---> fac(5) calls fac(4) ----+	       .....
					       |
        +<-------------------------------------+ fac(4) finishes
        |				         and returns...
        | Register A6 has CHANGED !
```
Notice that register A6 would have changed when fac(4) returns back to fac(5) if fac(4) does not restore the value of A6

To enable the recursive function to restore the frame pointer, the function will save the value in A6 on the stack.

So the stack structure above is extending to include the frame pointer:

             +----------------+
             |    local vars  | <- fac allocates local vars
             +----------------+
   my A6 --> | A6 of my caller| <- fac save the fp of its caller
             +----------------+
             |     retaddr    | <- retaddr pushed when main calls fac
             +----------------+
             |       n        | <- main pushes parameter n first
             +----------------+