a = a + 1;

lw      $t0,12($fp)    # get a
addiu   $t0,$t0,1      # a + 1
sw      $t0,12($fp)    # a = 

Frame-based Linkage Convention

Calling a Subroutine (done by the caller):

1. Push any registers $t0-$t9 that contain values that must be saved. Push the registers in numerical order.
2. Put argument values into $a0-$a3.
3. Call the subroutine using jal.

Subroutine Prolog (done by the subroutine):

4. Push $ra (always).
5. Push the caller's frame pointer $fp.
6. Push any of the registers $s0-$s7 that the subroutine might alter.
7. Initialize the frame pointer: $fp = $sp - space_for_variables. The "space for variables" is four times the number of local variables. (Remember that subtracting from $sp grows the stack, and that our variables are always four bytes wide).
8. Initialize the stack pointer: $sp = $fp.

Subroutine Body:

9. At this point the stack looks like the above picture.
10. The subroutine may alter any T, A, or V register, or any S register that it saved in the prolog.
11. The subroutine refers to local variables as disp($fp).
12. The subroutine may push and pop values on the stack using $sp.
13. If the subroutine calls another subroutine, then it does so by following these rules.

Subroutine Epilog (done at the end of the subroutine):

14. Put return values in $v0-$v1
15. $sp = $fp + space_for_variables.
16. Pop into $s0-$s7 any values for them that were previously saved in the frame.
17. Pop the caller's frame pointer into $fp.
18. Pop $ra (always).
19. Return to the caller using jr $ra.

Regaining Control from a Subroutine (done by the caller):

20. Pop any registers $t0-$t9 that the caller previously pushed.