Part 2 - MIPS

Parameter transferring

When calling a function in C code, what is happening at the assembler level is, calling a subroutine (usually).

What we need to do before a subroutine call, is the following:

1. Place the input parameters into their respective registers
2. Call the function/subroutine
3. Allocate memory for eventual saved and local variables
4. Execute the function/procedure
5. Place the result in a register
6. Reset the stack, if needed
7. Return to where the function/subroutine got called.

Register conventions

Since we now need to store our input parameters into register before we call a function, we need to create a convention to where we expect things to be.

MIPS has this following convention:

• $a_0 - a_3$: Input parameters

• $v_0, v_1$: Result values

• $t_0 - t_9$: Temporary variables

• $s_0 - s_7$: “Saved” registers

  • Must be saved and reset by each respective subroutine.

• $gp$: global pointer

• $sp$: stack pointer

• $fp$: frame pointer

• $ra$: return address

We discussed a lot of subroutines, but how do we actually call one?

jal Label will jump to a label (starting point of a subroutine).

To return from a subroutine call jr $ra.

A very simple function like:

1
int example(int g, int h, int i, int j) {
2
    int f;
3
    f = (g + h) - (i + j);
4
    return f;
5
}

Given that the arguments are in $a_0, \ldots, a_3$, f is in $s_0$ (therefore we must save $s_0$ to the stack before!).

The result will be stored in $v_0$

MIPS Code:

1
example:
2
    addi $sp, $sp, -4   # Allocate space for one variable, s_0
3
    sw   $s0, 0($sp)    # Save s_0
4

5
    add  $t0, $a0, $a1  # (g + h)
6
    add  $t1, $a2, $a3  # (i + j)
7
    sub  $s0, $t0, $t1  # f = (g + h) - (i + j)a
8

9
    add  $v0, $s0, $zero # Store value
10

11
    lw   $s0, 0($sp) # Reset s_0 value
12
    addi $sp, $sp, 4 # Reset stack pointer
13

14
    jr   $ra         # Return

Let’s now take a recursive

1
int fact(int n) {
2
    if(n < 1) {
3
        return 1;
4
    } else {
5
        return n * fact(n - 1);
6
    }
7
}

input parameter n in $a_0$, result in $v_0$

MIPS:

1
fact:
2
    addi $sp, $sp, -8   # Adjust stack so we can store 2 variables
3
    sw   $ra, 4($sp)    # Save return address
4
    sw   $a0, 0($sp)    # Save input register
5

6
    slti $t0, $a0, 1    # test for n < 1
7
    beq  $t0, $zero, L1
8
    addi $v0, $zero, 1  # If n < 1, result = 1
9

10
    addi $sp, $sp, 8    # Pop stack
11
    jr   $ra            # Return
12

13
L1: addi $a0, $a0, -1   # Decrement n
14
    jal  fact           # Recursive call
15

16
    lw   $a0, 0($sp)    # restore orignal n
17
    lw   $ra  4($sp)    # and return address
18

19
    addi $sp, $sp, 8    # Pop stack
20
    mul  $v0, $a0, $v0  # n * fact(n - 1)
21
    jr   $ra            # return

Less than a word

Sometimes we want to only access a byte or half-word:

1
lb rt, offset(rs)
2
lh rt, offset(rs)
3

4
# Unsigned
5
lbu rt, offset(rs)
6
lhu rt, offset(rs)
7

8
# Save
9
sb rt, offset(rs)
10
sh rt, offset(rs)

Indexing vs Pointers

• Vector indexing requires:

  • Multiplication of the index with length

  • Summation of this product to the vectors start address

• Pointer corresponds directly to a memory address

  • Therefore, it’s faster

Common mistakes

Common mistakes when writing programs in MIPS are:

• Incrementing with 1 and not 4!

• MIPS uses byte addressing