1. MIPS ISA-II: Procedure Calls & Program Assembly

2. (2) Module Outline Review ISA and understand instruction encodings Arithmetic and Logical Instructions Review memory organization Memory (data movement) instructions Control flow instructions Procedure/Function calls Program assembly, linking, & encoding

3. (3) Reading Reading 2.8, 2.12 Appendix B: B1 - B.6

4. (4) Procedure Calls Basic functionality  Transfer of parameters & control to procedure  Transfer of results & control back to the calling program  Support for nested procedures What is so hard about this?  Consider independently compiled code modules oWhere are the inputs? oWhere should I place the outputs? oRecall: What do you need to know when you write procedures in C?

5. (5) Specifics Where do we pass data  Preferably registers  make the common case fast  Memory as an overflow area Nested procedures  The stack, $fp, $sp and $ra  Saving and restoring machine state Set of rules that developers/compilers abide by  Which registers can am I permitted to use with no consequence?  Caller and callee save conventions for MIPS

6. (6) Basic Parameter Passing Register usage What about nested calls? What about excess arguments?.data arg1:.word 22, 20, 16, 4 arg2:.word 33,34,45,8.text addi $t0, $0, 4 move $t3, $0 move $t1, $0 move $t2, $0 loop: beq $t0, $0, exit addi $t0, $t0, -1 lw $a0, arg1($t1) lw $a1, arg2($t2) jal func add $t3, $t3, $v0 addi $t1, $t1, 4 addi $t2, $t2, 4 j loop func:sub $v0, $a0, $a1 jr $ra exit:--- $31 PC +4 Normally: Arguments put in $a0, $a1, $a2, $a3 Values returned in $v0, $v1

7. (7) Leaf Procedure Example C code: int leaf_example (int g, h, i, j) { int f; f = (g + h) - (i + j); return f; }  Arguments g, …, j are passed in $a0, …, $a3  f in $s0 (we need to save $s0 on stack – we will see why later)  Results are returned in $v0, $v1 $a0 $a1 $a2 $a3 $v0 $v1 argument registers result registers procedure

8. (8) Procedure Call Instructions Procedure call: jump and link jal ProcedureLabel  Address of following instruction put in $ra  Jumps to target address Procedure return: jump register jr $ra  Copies $ra to program counter  Can also be used for computed jumps oe.g., for case/switch statements Example:

9. (9) Leaf Procedure Example MIPS code: leaf_example: addi $sp, $sp, -4 sw $s0, 0($sp) add $t0, $a0, $a1 add $t1, $a2, $a3 sub $s0, $t0, $t1 add $v0, $s0, $zero lw $s0, 0($sp) addi $sp, $sp, 4 jr $ra Save $s0 on stack Procedure body Restore $s0 Result Return

10. (10) Procedure Call Mechanics Old Stack Frame arg registers return address Saved registers local variables New Stack Frame $fp $sp Low Address High Address compiler ISA HW compiler addressing $gp PC $sp stack dynamic data static data text reserved System Wide Memory Map $fp is fixed during the procedure. $sp changes as data is pushed and popped. Addressing data is easier if offset from $fp is used.

11. (11) Example of the Stack Frame Call Sequence 1. place excess arguments 2. save caller save registers ($a0-$a3, $t0-$t9) 3. jal 4. allocate stack frame 5. save callee save registers ($s0-$s9, $fp, $ra) 6 set frame pointer Return 1. place function argument in $v0 2. restore callee save registers 3. restore $fp 4. pop frame 5. jr $31 arg 1 arg 2.. callee saved registers caller saved registers local variables.. $fp – caller’s $ra $s0-$s9 $a0-$a3 $t0-$t9 $fp $sp

12. (12) Policy of Use Conventions

13. (13) Summary: Register Usage $a0 – $a3: arguments (reg ’ s 4 – 7) $v0, $v1: result values (reg ’ s 2 and 3) $t0 – $t9: temporaries  Can be overwritten by callee (so, caller-saved) $s0 – $s7: saved  Must be saved/restored by callee $gp: global pointer for static data (reg 28) $sp: stack pointer (reg 29) $fp: frame pointer (reg 30) $ra: return address (reg 31) (caller-saved) Red names – must be saved by caller because the callee can change them without restoring.

14. (14) Non-Leaf Procedures Procedures that call other procedures For nested call, caller needs to save on the stack:  Its return address  Any arguments and temporaries needed after the call Restore from the stack after the call

15. (15) Non-Leaf Procedure Example C code: int fact (int n) { if (n < 1) return f; else return n * fact(n - 1); }  Argument n in $a0  Result in $v0

16. (16) Template for a Procedure 1.Allocate stack frame (decrement stack pointer) 2.Save any registers (callee save registers) 3.Procedure body (remember some arguments may be on the stack!) 4.Restore registers (callee save registers) 5.Pop stack frame (increment stack pointer) 6.Return (jr $ra)

17. (17) Non-Leaf Procedure Example MIPS code: fact: addi $sp, $sp, -8 # adjust stack for 2 items sw $ra, 4($sp) # save return address sw $a0, 0($sp) # save argument slti $t0, $a0, 1 # test for n < 1 beq $t0, $zero, L1 addi $v0, $zero, 1 # if so, result is 1 addi $sp, $sp, 8 # pop 2 items from stack jr $ra # and return L1: addi $a0, $a0, -1 # else decrement n jal fact # recursive call lw $a0, 0($sp) # restore original n lw $ra, 4($sp) # and return address addi $sp, $sp, 8 # pop 2 items from stack mul $v0, $a0, $v0 # multiply to get result jr $ra # and return

18. (18) Module Outline Review ISA and understand instruction encodings Arithmetic and Logical Instructions Review memory organization Memory (data movement) instructions Control flow instructions Procedure/Function calls Program assembly, linking, & encoding

19. (19) The Complete Picture C program compiler Assembly assembler Object module executable linker loader memory Object libarary Reading: 2.12, B2, B3, B4, B5

20. (20) The Assembler Create a binary encoding of all native instructions  Translation of all pseudo-instructions  Computation of all branch offsets and jump addresses  Symbol table for unresolved (library) references Create an object file with all pertinent information Header (information) Text segment Data segment Relocation information Symbol table Example :

21. (21) One pass vs. two pass assembly Effect of fixed vs. variable length instructions Time, space and one pass assembly Local labels, global labels, external labels and the symbol table Absolute addresses and re-location Assembly Process

22. (22) Example. data L1:.word 0x44,22,33,55 # array.text.globl main main:la $t0, L1 li $t1, 4 add $t2, $t2, $zero loop:lw $t3, 0($t0) add $t2, $t2, $t3 addi $t0, $t0, 4 addi $t1, $t1, -1 bne $t1, $zero, loop bgt $t2, $0, then move $s0, $t2 j exit then:move $s1, $t2 exit: li $v0, 10 syscall [00400000] 3c081001lui $8, 4097 [L1] [00400004] 34090004ori $9, $0, 4 [00400008] 01405020add $10, $10, $0 [0040000c] 8d0b0000lw $11, 0($8) [00400010] 014b5020add $10, $10, $11 [00400014] 21080004addi $8, $8, 4 [00400018] 2129ffff addi $9, $9, -1 [0040001c] 1520fffc bne $9, $0, -16 [loop-0x0040001c] [00400020] 000a082aslt $1, $0, $10 [00400024] 14200003bne $1, $0, 12 [then-0x00400024] [00400028] 000a8021addu $16, $0, $10 [0040002c] 0810000dj 0x00400034 [exit] [00400030] 000a8821addu $17, $0, $10 [00400034] 3402000aori $2, $0, 10 [00400038] 0000000csyscall Assembly Program Native Instructions Assembled Binary What changes when you relocate code?

23. (23) Linker & Loader Linker  “Links” independently compiled modules  Determines “real” addresses  Updates the executable file with real addresses Loader  As the name implies, loads executable file into memory, initializes registers, schedules run with OS.  Specifics are operating system dependent

24. (24) Linking Why do we need independent compilation? What are the issues with respect to independent compilation? references across files absolute addresses and relocation Program AProgram B Assembly A Assembly B cross reference labels header text static data reloc symbol table debug Study: Example on pg. 143

25. (25) Example: # separate file.text addi $4, $0, 40x20050004 addi $5, $0, 50x20050005 jal func_add 000011 & 26-bit addr/4 done0x0340200a 0x0000000c # separate file.text.globl func_add func_add: add $2, $4, $5 0x00851020 jr $31 0x03e00008 0x00400000 0x20040004 0x004000040x20050005 0x00400008? 0x0040000c0x3402000a 0x004000100x0000000c Ans: 0x0c100005. 0x00400014 0x008551020 0x004000180x03e00008 0x0 0 4 0 0 0 0 1 4 32-bit addr 0000 0000 0100 0000 0000 0000 0000 0001 0100 in binary 0x 0 1 0 0 0 0 0 5 26-bit addr

26. (26) Arrows indicate relative addresses that must be converted to absolute addresses and inserted into compiled "text" (machine code). X and Y are labels for locations where variables are stored. A and B are labels for locations where jumps will go to. With a virtual memory system, the Loader will not have to do any address translations. Textbook p.144 Linking 2 Object Files Object File A Object File B add memory offset

27. (27) Loading a Program Load from image file on disk into memory 1.Read header to determine segment sizes 2.Create virtual address space 3.Copy text and initialized data into memory oOr set page table entries so they can be faulted in 4.Set up arguments on stack 5.Initialize registers (including $sp, $fp, $gp) 6.Jump to startup routine oCopies arguments to $a0, … and calls main oWhen main returns, do exit syscall

28. (28) Dynamic Linking Only link/load library procedure when it is called  Requires procedure code to be relocatable  Avoids image bloat caused by static linking of all (transitively) referenced libraries  Automatically picks up new library versions

29. (29) Lazy Linkage Indirection table Stub: Loads routine ID, Jump to linker/loader Linker/loader code Dynamically mapped code

30. (30) The Computing Model Revisited 0xFFFFFFFF Arithmetic Logic Unit (ALU) 0x00 0x01 0x02 0x03 0x1F Processor Internal Buses Memory Interface Register File (Programmer Visible State) stack Data segment (static) Text Segment Dynamic Data Reserved Program Counter Programmer Invisible State Kernel registers Program Execution and the von Neumann model Memory Map Instruction register 0x0FFFFFFC 0x0400000

31. (31) Instruction complexity is only one variable  lower instruction count vs. higher CPI / lower clock rate Design Principles:  simplicity favors regularity  smaller is faster  good design demands compromise  make the common case fast Instruction set architecture  a very important abstraction indeed! Summary

32. (32) Study Guide Compute number of bytes to encode a SPIM program What does it mean for a code segment to be relocatable? Identify addresses that need to be modified when a program is relocated.  Given the new start address modify the necessary addresses Given the assembly of an independently compiled procedure, ensure that it follows the MIPS calling conventions, modifying it if necessary

33. (33) Study Guide (cont.) Given a SPIM program with nested procedures, ensure that you know what registers are stored in the stack as a consequence of a call Encode/disassemble jal and jr instructions Computation of jal encodings for independently compiled modules

34. (34) Glossary Argument registers Caller save registers Callee save registers Disassembly Frame pointer Independent compilation Labels: local, global, external Linker/loader Linking: static vs. dynamic vs. lazy Native instructions Nested procedures Object file One/two pass assembly Procedure invocation Pseudo instructions Relocatable code Stack frame Stack pointer Symbol table