MIPS Calling Convention

Procedure Calls Procedure must work the same from any call Procedure uses regs that main was using We need a convention to –pass arguments –preserve registers, stack –pass return values Main Procedure Call Procedure

NameReg NumberUsagePreserved across call? $zero0The constant 0Yes $v0-$v12-3Function resultsNo $a0-$a34-7Function ArgumentsNo $t0-$t78-15TemporariesNo $s0-$s716-23SavedYes $t8-$t924-25More temporariesNo $gp28Global pointerYes $sp29Stack pointerYes $fp30Frame pointerYes $ra31Return addressYes Page 140, Figure 3.13 MIPS-specific info

MIPS-specific info – who cares? Preserved – Value is same after call –Caller – excellent! no worries! –Procedure – may not destroy value must store at beginning and restore at end to use Not preserved – No guarantees –Caller – loses value in register most store before call and restore after call –Procedure – may use without worries

Steps for caller 0. Store any temp regs whose values we need Pass function parameters to procedure Transfer control to procedure (then procedure executes) Get return value Restore any temp regs we saved away

Steps for procedure 1.Allocate stack space 2.Store preserved regs we may use 3.Perform task 4.Place result in proper location for caller 5.Restore preserved regs we may have used 6. Deallocate stack space 7. Transfer control back to caller

Write the caller & procedure code for the following function: Caller: Callee: Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);}

Caller: 1. Save any temp regs Caller:Callee: Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);}

Caller: 1. Save any temp regs Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Caller: sw $t0, 0($sp) Callee: int MyFunc(int g, int h) {return (g + h);} Stack space must have been allocated for $t0

Caller: 2. Pass parameters Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp)

Caller: 2. Pass parameters Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero move args into $a0-$a3 additional args in stack

Caller: 2. Pass parameters Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero move args into $a0-$a3 additional args in stack g must be in $a0, h must be in $a1

Caller: 3. Transfer Control Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero

Caller: 3. Transfer Control Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc jal jumps *and* stores PC of instruction AFTER jal in $ra

Caller: 5. Get return value Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc

Caller: 5. Get return value Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero Move return value from $v0, also $v1 if 64 bits

Caller: 6. Restore regs Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero

Caller: 4. Restore regs Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Load from same location in the stack

Steps for procedure 1.Allocate stack space 2.Store preserved regs we may use 3.Perform task 4.Place result in proper location for caller 5.Restore preserved regs we may have used 6.Transfer control back to caller How do we know what we’ll use until we write task code? How do we know how much space until we know how many regs to store?

Callee: 3. Perform task Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp)

Callee: 3. Perform task Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: add $s0, ___, ___ int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) In what regs are g & h?

Callee: 3. Perform task Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. Callee: add $s0, $a0, $a1 int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) In what regs are g & h? args: $a0, $a1

Callee: 2. Store used preserved regs Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: add $s0, $a0, $a1

NameReg NumberUsagePreserved across call? $zero0The constant 0Yes $v0-$v12-3Function resultsNo $a0-$a34-7Function ArgumentsYes $t0-$t78-15TemporariesNo $s0-$s716-23SavedYes $t8-$t924-25More temporariesNo $gp28Global pointerYes $sp29Stack pointerYes $fp30Frame pointerYes $ra31Return addressYes Page 140, Figure 3.13 MIPS-specific info When is the $ra destroyed? When we make a function call - jal So when do we need to preserve it? If the function makes any calls

Definitions Leaf function –Makes no function calls –You need not store $ra into the stack Non-leaf function –Contains a function call –You MUST store $ra in the stack and restore before returning to caller

Callee: 2. Store used preserved regs Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: sw $s0, 0 ($sp) add $s0, $a0, $a1

Callee: 1. Allocate space Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: sw $s0, 0 ($sp) add $s0, $a0, $a1

How much stack space? Minimum allocation 24 bytes –$ra, $fp even if unused. –4 words for $a0-$a3 in case we need it Preserved registers that we destroy Local variables declared in our function Any other outgoing arguments (non-leaf)

Allocating stack space $sp Stack space for this function Only allocate once per function!!!! $sp contains address of bottom of stack. What operation on $sp allocates space? Minimum allocation: 24 bytes

Callee: 1. Allocate stack space Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, ___ sw $s0, 0 ($sp) add $s0, $a0, $a1

Callee: 1. Allocate stack space Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s2, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1

Callee: 4. Place return value Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1

Callee: 4. Place return value Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add ___, $s0, $zero Where does the return value go?

Callee: 4. Place return value Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add $v0, $s0, $zero Where does the return value go? Function return - $v0

Callee: 5. Restore preserved regs Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add $v0, $s0, $zero

Callee: 5. Restore preserved regs Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add $v0, $s0, $zero lw $s0, 0 ($sp)

Callee: 6. Deallocate space Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add $v0, $s0, $zero lw $s0, 0 ($sp)

Callee: 6. Deallocate space Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s2, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add $v0, $s0, $zero lw $s0, 0 ($sp) addi $sp, $sp, 32

Callee: 7. Return to caller Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add $v0, $s0, $zero lw $s0, 0 ($sp) addi $sp, $sp, 32

Callee: 7. Return to caller Assume: g,h are in $s2,$s3. We want return value in $s0. Caller wants to preserve $t0 across function call. int MyFunc(int g, int h) {return (g + h);} Caller: sw $t0, 0($sp) add $a0, $s2, $zero add $a1, $s3, $zero jal MyFunc add $s0, $v0, $zero lw $t0, 0($sp) Callee: addi $sp, $sp, -32 sw $s0, 0 ($sp) add $s0, $a0, $a1 add $v0, $s0, $zero lw $s0, 0 ($sp) addi $sp, $sp, 32 jr $ra

What actually goes in stack $ra Extra Arguments Extra outgoing arguments $sp before call $sp during call padding local data L*4 bytes for local data P*4 bytes for preserved regs ($s0-$s7) A*4 bytes for outgoing args $fp preserved registers (and $a0-$a3) $fp during call

Example int foo(int arg1, int arg2) { int myarray[64]; myarray[3] = 5; … bar(a1, a2, a3, a4, a5); … return (myarray[3]); } Local 256- byte array Non-leaf function Assume it needs 2 saved registers

Caller’s Stack addi$sp, $sp, - ( )*4 sw$ra, 73*4($sp) sw$fp, 72*4($sp) sw$s1, 67*4($sp) sw$s0, 66*4($sp) addi$t0, $zero,5# $t0 = 5 sw$t0, (1+3)*4 ($sp)# myarray[3] = 5 … lw$ra, 73*4($sp) lw$fp, 72*4($sp) lw$s1, 67*4($sp) lw$s0, 66*4($sp) addi$sp, $sp, ( )*4 jr $ra $a3 myarray $sp before call $sp during call $a2 $s1 $s0 padding outgoing arg 5 $ra $fp $a0 $a1

addi$sp, $sp, - ( )*4 sw$ra, 73*4($sp) sw$fp, 72*4($sp) sw$s1, 67*4($sp) sw$s0, 66*4($sp) addi$t0, $zero,5# $t0 = 5 sw$t0, (1+3)*4 ($sp)# myarray[3] = 5 … lw$ra, 73*4($sp) lw$fp, 72*4($sp) lw$s1, 67*4($sp) lw$s0, 66*4($sp) addi$sp, $sp, ( )*4 jr $ra $sp before call $sp during call Caller’s Stack $a3 myarray $a2 $s1 $s0 padding outgoing arg 5 $ra $fp $a0 $a1

outgoing arg 5 addi$sp, $sp, - ( )*4 sw$ra, 73*4($sp) sw$fp, 72*4($sp) sw$s1, 67*4($sp) sw$s0, 66*4($sp) addi$t0, $zero,5# $t0 = 5 sw$t0, (1+3)*4 ($sp)# myarray[3] = 5 … lw$ra, 73*4($sp) lw$fp, 72*4($sp) lw$s1, 67*4($sp) lw$s0, 66*4($sp) addi$sp, $sp, ( )*4 jr $ra myarray $sp before call $sp during call $s0 padding Caller’s Stack $a3 $a2 $ra $fp $a0 $a1 $s1

outgoing arg 5 padding addi$sp, $sp, - ( )*4 sw$ra, 73*4($sp) sw$fp, 72*4($sp) sw$s1, 67*4($sp) sw$s0, 66*4($sp) addi$t0, $zero,5# $t0 = 5 sw$t0, (1+3)*4 ($sp)# myarray[3] = 5 … lw$ra, 73*4($sp) lw$fp, 72*4($sp) lw$s1, 67*4($sp) lw$s0, 66*4($sp) addi$sp, $sp, ( )*4 jr $ra myarray $sp before call $sp during call $s1 $s0 Caller’s Stack $a3 $a2 $ra $fp $a0 $a1 Stack must be aligned to 64-bits (Even number of 32-bit slots)

outgoing arg 5 $s1 $s0 padding addi$sp, $sp, - ( )*4 sw$ra, 73*4($sp) sw$fp, 72*4($sp) sw$s1, 67*4($sp) sw$s0, 66*4($sp) addi$t0, $zero,5# $t0 = 5 sw$t0, (1+3)*4 ($sp)# myarray[3] = 5 … lw$ra, 73*4($sp) lw$fp, 72*4($sp) lw$s1, 67*4($sp) lw$s0, 66*4($sp) addi$sp, $sp, ( )*4 jr $ra myarray $sp before call $sp during call Caller’s Stack $a3 $a2 $ra $fp $a0 $a1

outgoing arg 5 $s1 $s0 padding addi$sp, $sp, - ( )*4 sw$ra, 73*4($sp) sw$fp, 72*4($sp) sw$s1, 67*4($sp) sw$s0, 66*4($sp) addi$t0, $zero,5# $t0 = 5 sw$t0, (1+3)*4 ($sp)# myarray[3] = 5 … lw$ra, 73*4($sp) lw$fp, 72*4($sp) lw$s1, 67*4($sp) lw$s0, 66*4($sp) addi$sp, $sp, ( )*4 jr $ra myarray $sp before call $sp during call Caller’s Stack $a3 $a2 $ra $fp $a0 $a1 Minimum Allocation

Recursive call: int SumToN(int N) { if (N < 2) return 1; else return (SumToN(N-1) + N); } Both the caller and the callee!!! SumToN: result: end:

Recursive call: int SumToN(int N) { if (N < 2) return 1; else return (SumToN(N-1) + N); } Both the caller and the callee!!! SumToN: slti $t0, $a0, 2 beq $t0, $0, result result: end:

Recursive call: int SumToN(int N) { if (N < 2) return 1; else return (SumToN(N-1) + N); } Both the caller and the callee!!! SumToN: slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: end:

Recursive call: int SumToN(int N) { if (N < 2) return 1; else return (SumToN(N-1) + N); } Both the caller and the callee!!! SumToN: slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: addi $a0, $a0, -1 jal SumToN add $v0, $v0, $a0 end:

Recursive call: int SumToN(int N) { if (N < 2) return 1; else return (SumToN(N-1) + N); } Both the caller and the callee!!! SumToN: slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: Store and restore $a0

Recursive call: SumToN int SumToN(int N) { if (N < 2) return 1; else return (SumToN(N-1) + N); } Both the caller and the callee!!! SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $fp $sp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $fp $sp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $a0=2 $fp $sp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $a0=2 $fp $sp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(1) $sp $a0=2 $fp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(1) $sp $a0=2 $fp $ra $fp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(1) $sp $a0=2 $fp $ra $fp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(1) $fp $sp $ra $v0 = 1 $a0=2 $fp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $fp $sp $ra $v0 = 1 $a0=2 $fp $ra SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp $v0 = 1 $a0=2 $fp $ra $fp $ra $a0=1 SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp $v0 = 1 $a0=2 $fp $ra $fp $ra $a0=1 SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp $v0 = 3 $a0=2 $fp $ra $fp $ra $a0=1 SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp $v0 = 3 $a0=2 $fp $ra $fp $ra $a0=1 SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp $v0 = 3 $a0=2 $fp $ra $fp $ra $a0=1 SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp $v0 = 3 $a0=2 $fp $ra $fp $ra $a0=1 SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra

MIPS Stack SumToN(2) $sp $v0 = 3 What about this garbage in the stack? $a0=2 $fp $ra $fp $ra $a0=1 SumToN: addi $sp, $sp, -24 sw $ra, 20 ($sp) sw $fp, 16 ($sp) addi $fp, $sp, 20 slti $t0, $a0, 2 beq $t0, $0, result addi $v0, $zero,1 j end result: sw $a0, 0 ($sp) addi $a0, $a0, -1 jal SumToN lw $a0, 0 ($sp) add $v0, $v0, $a0 end: lw $ra, 20 ($sp) lw $fp, 16 ($sp) addi $sp, $sp, 24 jr $ra