Procedures

Why use procedures? ? Microprocessors (and assembly languages) provide only minimal support for procedures Must build a standard form for procedures

Procedures Procedure call {.. x = larger (a, b);. } Procedure header and parameters int larger (int one, int two) Procedure body { if (one > two) larger = one; else larger = two; }

Procedures Steps in the execution of the procedure: 1.Save return address 2.Procedure call 3.Execute procedure 4.Return What is the return address? What is the procedure call? What is the return? MAL uses registers rather than variables for return address

Procedures Modern load/store machines (MAL, MIPS, SPARC,…) have a jump and link instruction for procedure calls jal procname Place the address of the instruction following it into the register $ra ($31) $31 is an arbitrary (and common) choice made at architecture time. Why isn’t $31 specified in the instruction as: jal $31, procname #NOT VALID CODE Branches (jumps) to the address given by the label (procname).

Procedures The example becomes: jal proc1 # use of $ra is implied. jal proc1. proc1:# 1 st instruction of procedure here. jr $ra# $ra is the alias for $31

Nested Procedures What happens if a procedure calls another procedure (nesting) using jal? jal proc1. jal proc1. proc1:. jal proc2. jr $ra proc2:.. jr $ra

Nested Procedures Even more exciting, what happens if a procedure calls itself (recursion)? jal proc1. jal proc1. Proc1:.. jal proc1. jr $ra

Nested Procedures Must save return address as generated Unknown how many to save Needed in reverse order of saved Use a …

System Stack A stack is so frequently used for procedure call/return, that many computer systems predefine a system stack. The system stack is for dynamic data (vs static, known before runtime) Return addresses Saving registers to move other data into register bank (“spilling”) Local variables – several instances may be defined at once with multiple calls Dynamic memory allocation The system stack is very large In a multi-user environment, how many system stacks are there?

System Stack The MIPS system stack (as with most machines) is defined to grow toward smaller addresses The stack pointer points to an empty location at the top of the stack The stack pointer is register #29, also called $sp It is defined before program execution begins If $sp ($29) is used for any other purpose, then the stack pointer is lost. This would be bad, very bad. address 0 your program here very large addresses system stack here Grows towards smaller addresses

System Stack push, in MAL: sw$?, ($sp)# the $? Is replaced by some register sub$sp, $sp, 4# contains the data to be pushed Or sub$sp, $sp, 4 sw$?, 4($sp) pop, in MAL: Or Which forms are better if there is an interrupt that uses the same stack?

System Stack Often a procedure pushes/pops many things. add$sp, $sp, -4 sw$8, 4($sp) add$sp, $sp, -4 sw$9, 4($sp) add$sp,$sp, -4 sw$10, 4($sp) But we do not need to change $sp each time. add$sp, $sp, -12 sw$8, 12($sp) sw$9, 8($sp) sw$10,4($sp) And with pop as well (do the add first or last?)

System Stack: Saving Return Addresses jaldoit. jaldoit. doit:sub $sp, $sp, 4#push return address sw $ra, 4($sp). jal another#this would overwrite the return.#address if it had not been saved. lw$ra, 4($sp)#pop return address add$sp, $sp, 4 jr$ra Note how every pop has a push. Never leave a procedure without popping everything that was pushed. Always match up your pushes and pops.

Parameter Passing Parameter = Argument There is even less architectural support for parameter passing Create a convention Follow the convention Follow the convention carefully Follow the convention consistently Never change the convention once defined Place data in a specific parameter location Both the calling program and the procedure need to know where the parameters are. Procedure may place return values there.

Parameter Passing Call by value (C, C++) The parameter passed may not be modified by the procedure. This can be implemented by passing a copy of the value. The procedure can modify the value (copy) passed to it, but the value is not changed outside the scope of the procedure. Call by reference (Fortran, C++ &, Pascal var) The parameter passed to the subroutine can be modified. The modification is seen outside the scope of the subroutine. Similar to having access to global variable. Ways of implementing these 2 variable types? ?

Parameter Passing Simplest mechanism – registers The calling program puts the parameter(s) into specific registers, and the procedure uses them.. move$s4, $s2# put parameter in register 4 jaldecrement move$s2, $s4# recopy parameter to its correct place. decrement: add$s4, $s4, -1 jr$ra This is a trivial example Why not just use $s2 within the procedure?

Parameters on Stack When there aren’t enough registers for all parameters, use the system stack in something called an activation record (AR). Used for all parameters in machines with few registers. eg. HC11, 6502, 8086, … sub$sp, $sp, 8# allocate space for parameters sw$9, 8($sp)# place parameter 1 into AR of proc sw$18, 4($sp)# place parameter 2 into AR of proc jalproc. proc: sub$sp, $sp, 12# allocate remainder of AR for proc # assume fixed size (too big) activation record lw$10, 20($sp)# retrieve parameter 1 lw$11, 16($sp)# retrieve parameter 2 # use parameters in procedure calculations add$sp, $sp, 20# remove AR of proc jr$ra

Parameters on a stack Calling program Allocate space for parameters Places parameters into stack Calls procedure Procedure: Allocates AR (or remainder of AR) De-allocates AR of procedure (or at least most of it) MIPS convention The first 4 parameters are passed in register The alias for $4-$7 is $a0-$a3. The first parameter is passed in $a0. Space for all parameters passed in $a0-$a3 is allocated in the procedure’s AR.

MIPS Convention If there are nested subroutine calls, and registers $a0-$a3 are used for parameters, the values would be lost procA:#receives 3 parameters in $a0, $a1, $a2 # set up procB’s parameters move $a0, $24# overwrites procA’s parameter in $a0 move $a1, $9# overwrites procA’s parameter in $a1 jal procB# the nested procedure call # procA continues after procB returns # procA’s parameters are needed, but have been overwritten Solutions…

MIPS Convention Caller Place parameters in $a0 to $a3 jal procedure Procedure Allocate remainder of AR and push $ra Procedure calculations To call proc2 Place current parameters (from $a0-$a3) into AR Set up parameters to proc2 in $a0-$a3 Call proc2 (jal proc2) Copy any return values out of $v0-v1, $a0-$a3 Restore current parameters from AR back to $a0-$a3 More procedure calculations Get procedure’s return address from AR De-allocate AR Return (jr $ra)

MIPS Convention # a set of procedures that do the following: # if a<b, then switch a with b and decrement both # a is in register 20 # b is in register 21.text sub$8, $20, $21 bgtz$8, othercode move$a0, $20# place parameters in a registers move$a1, $21 jals_and_d move$20, $a0# copy the return values move$21, $a1 othercode: done

MIPS Convention # s_and_d: swap its 2 parameters, and then both decrement both #$a0 ($4) – first parameter #$a1 ($5) – second parameter #$8 – temporary for switching s_and_d: sub$sp, $sp, 12# allocate frame for switch sw$ra, 12($sp)# save return address on stack move$t0, $a0# switch the 2 parameters move$a0, $a1# $t0 is alias for $8 move$a1, $t0 sw $a0, 8($sp)# save current parameters sw$a1, 4($sp) jaldecrement# the parameter to decrement is already # in $a0 lw$a0, 4($sp)# set up parameter in $a0 jaldecrement move$a1, $a0# copy return value lw$a0, 8($sp)# restore current parameter lw$ra, 12($sp)# get return address jr$ra # procedure decrement: subtracts 1 from parameter $a0 decrement: addi$a0, $a0, -1 jr$ra

Summary: Parameter Passing Styles 1.Use registers Advantages Disadvantages 2.Use some registers, and place the rest on the stack Advantages Disadvantages 3.Put all parameters on the stack (an unsophisticated compiler might do this) Advantages Disadvantages 4.Put parameters in memory set aside for them Advantages Disadvantages

Register Spilling On calling a procedure, many registers may be in use What should be done? Two solutions Callee saved A procedure clears out some registers for its own use Register values are preserved across procedure calls MIPS calls these saved registers: $s0-$s8 (aliases for $16-$23, $30) The called procedure Saves register values in its AR, Uses the register for local variables, Restores register values before it returns.

Register Spilling Caller Saved The calling program saves the registers that it does not want a called procedure to overwrite Register values are NOT preserved across procedure calls MIPS calls these temporary registers: $t0-$t9 (aliases for $8-$15, $24-$25) Procedures use there registers for local variables The values do not need to be preserved outside the scope of the procedure. How about $v0-$v1, and $a0-$a3?

Procedure Calls From the compiler’s point of view, a procedure call looks like: call setup procedure call return cleanup. procedure: prologue calculations epilogue

Procedure Calls The full convention includes Call Setup Save any callee-save registers that are currently in use Place current parameters into current stack frame Allocate space for all parameters for procedure to be called Change $sp by the total parameter size Place first 4 parameters to procedure into $a0-$a3 Place remaining parameters on stack Procedure Call JAL

Procedure Calls Prologue Allocate space for remainder of stack frame Save return address in stack frame Copy needed parameters from stack frame into registers Save any needed saved registers into current stack frame Epilogue Restore (copy) return address from stack frame into $ra Restore any saved registers De-allocate stack frame (or most of it) Move $sp so the space for the procedure’s frame is gone Return Cleanup Copy needed return values and parameters from $v0-$v1, $a0-$a3, or stack frame to correct places De-allocate remainder of procedure’s stack frame Move $sp so the space for the procedure’s frame is gone Restore any saved registers from call setup

Summary: Procedure Calls Minimal ASM support Need formal and consistent mechanism Why? Activation record includes ? Caller must… Callee must…