a = a + 1;

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

Frame-based Linkage Convention

---

Subroutine Prolog (at the start of a subroutine):

1. Push $ra (always).
2. Push the caller's frame pointer $fp.
3. Push any of the registers $s0-$s7 that the subroutine might alter.
4. 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).
5. Initialize the stack pointer: $sp = $fp.

Subroutine Body:

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

Subroutine Call: (done by the caller, which might itself be a subroutine):

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

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

14. Pop any registers $t0-$t9 that this caller pushed in step 11.

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

15. Put return values in $v0-$v1
16. $sp = $fp + space_for_variables.
    Now $sp points at the last S register that was pushed in the prolog.
17. Pop into $s0-$s7 any values for them that were previously saved by the prolog (in step 3).
18. Pop the caller's frame pointer into $fp.
19. Pop $ra.
20. Return to the caller using jr $ra.

---

Each push in the prolog (steps 1, 2, 3) is matched with a pop in the epilog (steps 17, 18, 19).

When a caller gets control back from a subroutine it called its frame pointer and stack pointer are the same as before it called the subroutine.