MIPS ISA-II: Procedure Calls & Program Assembly

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

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. Reading • Reading 2.8, 2.12 • Appendix B: B1 - B.6

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 • Where are the inputs? • Where should I place the outputs? • Recall: What do you need to know when you write procedures in C?

5. Specifics • Where do we pass data • Preferably registers  make the common case fast • Memory as an overflow area • Nested procedures • The stack, $fp, $spand $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 calleesave conventions for MIPS

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) jalfunc add $t3, $t3, $v0 addi $t1, $t1, 4 addi $t2, $t2, 4 j loop func: sub $v0, $a0, $a1 jr $ra exit: --- PC + 4 $31 PC $31

7. Leaf Procedure Example • C code: intleaf_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 result registers argument registers procedure $a2 $a3 $v0 $v1

8. Procedure Call Instructions • Procedure call: jump and link jalProcedureLabel • 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 • e.g., for case/switch statements Example:

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

10. Procedure Call Mechanics High Address System Wide Memory Map $fp $sp Old Stack Frame stack $sp $fp arg registers dynamic data static data return address $gp New Stack Frame text Saved registers PC reserved local variables $sp compiler compiler ISA addressing HW Low Address

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

12. Policy of Use Conventions

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 • $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)

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. Non-Leaf Procedure Example • C code: int fact (int n){ if (n < 1) return f; else return n * fact(n - 1);} • Argument nin $a0 • Result in $v0

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

17. Non-Leaf Procedure Example int fact (int n){ callee save if (n < 1) return f; else return n * fact(n - 1);restore }

18. Non-Leaf Procedure Example • MIPS code: fact:addi $sp, $sp, -8 # adjust stack for 2 itemssw $ra, 4($sp) # save return addresssw $a0, 0($sp) # save argumentslti $t0, $a0, 1 # test for n < 1beq $t0, $zero, L1addi $v0, $zero, 1 # if so, result is 1addi $sp, $sp, 8 # pop 2 items from stackjr $ra # and returnL1: addi $a0, $a0, -1 # else decrement n jal fact # recursive calllw $a0, 0($sp) # restore original nlw $ra, 4($sp) # and return addressaddi $sp, $sp, 8 # pop 2 items from stackmul $v0, $a0, $v0 # multiply to get resultjr $ra # and return Calleesave Termination Check Leaf Node Recursive call Intermediate Node

19. 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

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

21. 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 Example: Relocation information Symbol table

22. Assembly Process • 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 • What does mean when a symbol is unresolved? • Absolute addresses and re-location

23. Example What changes when you relocate code? .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] 3c081001 lui $8, 4097 [L1]        [00400004] 34090004 ori $9, $0, 4             [00400008] 01405020 add $10, $10, $0         [0040000c] 8d0b0000 lw $11, 0($8)            [00400010] 014b5020 add $10, $10, $11        [00400014] 21080004 addi $8, $8, 4           [00400018] 2129ffff   addi $9, $9, -1          [0040001c] 1520fffc   bne $9, $0, -16 [loop-0x0040001c][00400020] 000a082a slt $1, $0, $10          [00400024] 14200003 bne $1, $0, 12 [then-0x00400024] [00400028] 000a8021 addu $16, $0, $10        [0040002c] 0810000d j 0x00400034 [exit] [00400030] 000a8821 addu $17, $0, $10       [00400034] 3402000a ori $2, $0, 10          [00400038] 0000000c syscall Assembly Program Native Instructions Assembled Binary

24. Linker & Loader • Linker • “Links” independently compiled modules • Determines “real” addresses • Updates the executables with real addresses • Loader • As the name implies • Specifics are operating system dependent

25. Linking Program A Program B header text static data Assembly A Assembly B reloc symboltable cross reference labels debug • Why do we need independent compilation? • What are the issues with respect to independent compilation? • references across files (can be to data or code!) • absolute addresses and relocation Study: Example on pg. 143

26. Example: # separate file .text 0x20040004 addi $4, $0, 4 0x20050005 addi $5, $0, 5 000011 jalfunc_add done 0x0340200a 0x0000000c # separate file .text .globlfunc_add func_add: add $2, $4, $5 0x00851020 jr $31 0x03e00008 0x00400000 0x20040004 0x00400004 0x20050005 0x00400008 ? 0x0040000c 0x3402000a 0x00400010 0x0000000c 0x00400014 0x008551020 0x00400018 0x03e00008 Ans: 0c100005

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 • Or 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 • Copies arguments to $a0, … and calls main • When main returns, do exit syscall

28. Dynamic Linking • Static Linking • All labels are resolved at link time • Link all procedures that may be called by the program • Size of executables? • 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. Lazy Linkage Indirection table Stub: Loads routine ID,Jump to linker/loader Linker/loader code Dynamicallymapped code

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

31. Summary • 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!

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. 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 jalencodings for independently compiled modules • How can I make procedure calls faster? • Hint: What about a call is it that takes time? • How are independently compiled modules linked into a single executable? (assuming one calls a procedure located in another)

34. Glossary • Native instructions • Nested procedures • Object file • One/two pass assembly • Procedure invocation • Pseudo instructions • Relocatable code • Stack frame • Stack pointer • Symbol table • Unresolved symbol • 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