Procedures: Two Analogies

Subcontractor: Do this task, and give me your results when you're done.

Restaurant Kitchen Hatch: Waiter leaves menu order on a counter. Chef looks on the counter for an order, cooks the appropriate meal, leaves it on the counter. Server picks up the meal from the counter and delivers it to the customer.

Procedures: A Seven-Step Program

Calling Program:

• Place parameters in a place where the procedure can access them.
• Transfer control to the procedure.

Procedure:

• Acquire the storage resources needed for the procedure.
• Perform the desired task.
• Place the result values in a place where the calling program can access them.
• Release the storage resources needed for the procedure. (Not one of the steps listed on p. 97)
• Return control to the point of origin.
  How does the procedure know where that would be? Calling program specifies where the procedure should return to -- the instruction following the call to the procedure. This is set (automatically) as part of Step 2.

New Instructions

• jal (jump and link): Used to go to a procedure. First puts the program counter in $ra, then jumps to the beginning of the procedure.
• jr $ra (jump return): Jumps to the address stored in $ra (the instruction in the calling procedure to return to).

New Registers

• $a0, ..., $a3 are for procedure arguments
• $ra is for the return location
• $v0, $v1 are for return values

Note About Saved/Unsaved Registers

The conventions/rules of MIPS are that subfunctions may change the values of some registers, but not all of them.

• Subfunctions may change the argument registers ($a0 — $a3), the return value registers ($v0 & $v1), and the "temporary" registers ($t0 — $t9). These are the "unsaved" registers. Thus, if the calling code has values in those registers that it will use again after the subfunction call, it needs to save copies of them somewhere (called the Stack) before calling the subfunction, and restore the values after the subfunction returns.
• Calling code may assume that the "saved" registers ($s0 — $s7) and the return address register ($ra) will have the same values after a subfunction call as they did before the call. This means that if the subfunction needs to, or chooses to, modify the values in those registers, it must save copies of them to the Stack before changing them, and restore those values before returning to the calling code.