## Project 2 Background

### Background

This tutorial will guide you through the calling convention that we will be using for Project 2.   A calling convention is primarily concerned with where arguments go, and whether the caller or callee must save the registers.  We will be using the standard MIPS conventions for who must save registers, this tutorial will guide you through where to put arguments and where to find them.

NOTE: In all diagrams in this tutorial lower memory addresses are drawn on top!  Remember the stack grows towards lower memory addresses.  By flipping the diagrams we have made it so that the top of the stack corresponds to the top of the boxes in the diagram, but remember this is also the lowest address on the stack!

#### MIPS Stack Managing

By now, you should know how to manage the stack when writing procedures in MIPS. Let's assume you have a function light_blue, which calls a function dark_blue. The very first thing that light_blue does is to allocate space in the stack for its variables (prolog). In Figure 1 (middle) we can see that it allocates space for 4 words. light_blue eventually calls dark_blue, which allocates space for its own variables. Figure 1 (right) shows that dark_blue has allocated space for 2 words.

 Figure 1

#### MIPS Argument Passing

The MIPS procedure calling convention uses registers \$a0-\$a3 for passing arguments down to procedures. If there are more than four, the remaining arguments are passed on the stack. How is this mixed with the normal stack managing? Each argument (after the first four of course) gets one word of stack space. Suppose we are trying to write in MIPS assembler a program like this:

```int dark_blue (int x, int y, int quux, int bar, int bay, int baz) {

int a;
...
a = y;
...
}

int light_blue ( ) {

int c, d, e;
...
dark_blue (3, 4, 43, 62, 1, 0);
...
}
```

Procedure dark_blue has six integer arguments. The first four arguments will be stored in \$a0-\$a3. The space for the last two arguments is allocated on the stack as part of the caller's (light_blue) stack frame. In other words, light_blue, not dark_blue, must allocate the space.  This should be obvious from the fact that `light_blue` must fill in those values before calling `dark_blue` and must therefor have space for them.

Figure 2 shows this stack management method. light_blue now allocates space in the stack for its variables and the arguments that it will use to call dark_blue. We can see in Figure 2 (middle) that it allocates space for 6 words: 4 for its own consumption (variables c, d, and e as well as the return address), and 2 for calling dark_blue.

light_blue eventually calls dark_blue, which allocates space for its own variables. Figure 2 (right) shows that dark_blue has allocated space for 2 words (one for the return address and one for a). Note that dark_blue can access the 6 arguments by accessing the first four in the \$a0-\$a3 registers and the last two as the top of the stack reserved by its caller process (light_blue).

 Figure 2

The 2 spilled arguments (patterned light-blue stack) are located at the lower addresses of light_blue's stack frame, toward the top of the stack.

That is, light_blue will use 0(\$sp) to store the argument bay and 4(\$sp) to store the argument baz. Therefore, dark_blue will use 8(\$sp) to access the argument bay, 12(\$sp) to access the argument baz, and so on. Of course, arguments such as x are in registers (in x's case, \$a0).

Note that the first spilled argument is always at the caller's stack frame lowest address, and the last spilled argument at the highest address. You have to be consistent about this so that dark_blue knows which argument is which.

`light_blue:	# prolog        addi \$sp, \$sp, -16  # allocate stack space for 4 words:                             # \$ra, c, d, and e        sw   \$ra, 12(\$sp)   # save \$ra                            # use 0(\$sp) to save c (\$t0) when needed                            # use 4(\$sp) to save d (\$t1) when needed                            # use 8(\$sp) to save e (\$t2) when needed	# body        ...        addi \$t0, \$0, 3     # assume this holds the value of c        addi \$t1, \$0, 4     # assume this holds the value of d        addi \$t2, \$0, 5     # assume this holds the value of e        ...	# this is the call to dark_blue        addi \$sp, \$sp, -8  # allocate stack space for 2 words (patterned 	                    # light-blue): the args bay, baz        sw   \$t0, 8(\$sp)   # save c before calling dark_blue        sw   \$t1, 12(\$sp)   # save d before calling dark_blue        sw   \$t2, 16(\$sp)   # save e before calling dark_blue        add  \$a0, \$0, \$t0   # arg x = c        add  \$a1, \$0, \$t1   # arg y = d        addi \$a2, \$0, 43    # arg quux = 43        addi \$a3, \$0, 62    # bar = 62        addi \$t0, \$0, 1     # bay = 1, but no more registers        sw   \$t0, 0(\$sp)   # so pass on the stack        add  \$t0, \$0, \$0    # baz = 0, but no more registers        sw   \$t0, 4(\$sp)   # so pass on the stack        jal  dark_blue        addi \$sp, \$sp, 8   # restore stack space used for calling dark_blue        ...	# epilog        lw   \$ra, 12(\$sp)   # reload return address        addi \$sp, \$sp, 16   # restore stack space        jr   \$ra            # return to caller	...dark_blue:	# prolog        addi \$sp, \$sp, -8   # allocate stack space for 2 words:                            # \$ra, a        sw   \$ra, 4(\$sp)    # save \$ra                            # use 0(\$sp) to save a when needed	# body        ...        add  \$t0, \$0, \$a1   # get argument y        lw   \$t1, 12(\$sp)   # *** (see below)                            # 8 (dark_blue's frame) + 16 = 24 up on stack                            # fetched argument baz        ...	# epilog        lw   \$ra, 4(\$sp)    # reload return address        addi \$sp, \$sp, 8    # restore stack space        jr   \$ra            # return to caller`

The instruction indicated by `***` is the key to understanding the stack method of argument passing. Procedure `dark_blue` is referring to a word of stack memory that is from the caller's stack frame. Its own frame includes only the two words `0(\$sp)`, which contains `a` and `4(\$sp)`, which contains the return address.

Site Maintained by: Greg Gibeling (gdgib <at> berkeley.edu)