MIPS ISA-II: Procedure Calls & Program Assembly. (2) Module Outline Review ISA and understand...
-
Upload
ella-burdett -
Category
Documents
-
view
217 -
download
0
Transcript of MIPS ISA-II: Procedure Calls & Program Assembly. (2) Module Outline Review ISA and understand...
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
o Where are the inputs?o Where should I place the outputs?o 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, $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)
Basic Parameter Passing
• Register usage • What about nested
calls? • What about excess
arguments?
.dataarg1: .word 22, 20, 16, 4arg2: .word 33,34,45,8
.textaddi $t0, $0, 4move $t3, $0move $t1, $0move $t2, $0
loop: beq $t0, $0, exitaddi $t0, $t0, -1lw $a0, arg1($t1)lw $a1, arg2($t2)jal funcadd $t3, $t3, $v0addi $t1, $t1, 4addi $t2, $t2, 4j loop
func: sub $v0, $a0, $a1jr $ra
exit: ---
$31
$31
PC
PC
+ 4
Normally: Arguments put in $a0, $a1, $a2, $a3 Values returned in $v0, $v1
(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)
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
o e.g., for case/switch statements
Example:
(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)
Procedure Call Mechanics
Old Stack Frame
arg registers
return address
Saved registers
local variables
New Stack Frame
$fp
$fp
$sp
$sp
Low Address
High Address
compiler
ISA
HW
compiler
addressing
$gp
PC
$spstack
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)
Example of the Stack Frame
Call Sequence
1. place excess arguments2. save caller save registers ($a0-$a3, $t0-$t9)3. jal4. allocate stack frame5. save callee save registers ($s0-$s9, $fp, $ra)6 set frame pointer
Return1. place function argument in $v02. restore callee save registers3. restore $fp4. pop frame5. jr $31
arg 1
arg 2
..
calleesaved
registers
callersaved
registers
localvariables
.. $fp – caller’s
$ra
$s0-$s9
$a0-$a3$t0-$t9
$fp
$sp
(12)
Policy of Use Conventions
Name Register number Usage$zero 0 the constant value 0$v0-$v1 2-3 values for results and expression evaluation$a0-$a3 4-7 arguments$t0-$t7 8-15 temporaries$s0-$s7 16-23 saved$t8-$t9 24-25 more temporaries$gp 28 global pointer$sp 29 stack pointer$fp 30 frame pointer$ra 31 return address
(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)
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 n in $a0 Result in $v0
(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)
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 returnL1: 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)
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)
The Complete Picture
C program
compiler
Assembly
assembler
Object module
executable
linker
loader
memory
Object libarary
Reading: 2.12, B2, B3, B4, B5
(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 tableExample:
(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)
Example.data
L1: .word 0x44,22,33,55 # array
.text
.globl main
main: la $t0, L1li $t1, 4add $t2, $t2, $zero
loop: lw $t3, 0($t0)add $t2, $t2, $t3addi $t0, $t0, 4addi $t1, $t1, -1bne $t1, $zero, loop
bgt $t2, $0, thenmove $s0, $t2j exit
then: move $s1, $t2exit: 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
What changes when you relocate code?
(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)
Linking
• Why do we need independent compilation?
• What are the issues with respect to independent compilation?
• references across files• absolute addresses and relocation
Program A Program B
Assembly A Assembly B
cross referencelabels
header
text
static data
relocsymbol tabledebug
Study: Example on pg. 143
(25)
Example: # separate file
.textaddi $4, $0, 4 0x20050004addi $5, $0, 5 0x20050005jal func_add 000011 & 26-bit addr/4 done 0x0340200a
0x0000000c
# separate file
.text
.globl func_addfunc_add: add $2, $4, $5 0x00851020
jr $31 0x03e00008
0x00400000 0x20040004
0x00400004 0x20050005
0x00400008 ?
0x0040000c 0x3402000a
0x00400010 0x0000000c
Ans: 0x0c100005
.
0x00400014 0x008551020
0x00400018 0x03e00008
0x0 0 4 0 0 0 0 1 4 32-bit addr0000 0000 0100 0000 0000 0000 0000 0001 0100 in binary0x 0 1 0 0 0 0 0 5 26-bit addr
(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 jumpswill go to.
With a virtual memory system, the Loader will not have to do any address translations.
Textbook p.144
Linking 2 Object FilesObject File A
Object File B
add memory offset
(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 memoryo 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 routineo Copies arguments to $a0, … and calls maino When main returns, do exit syscall
(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)
Lazy Linkage
Indirection table
Stub: Loads routine ID,Jump to linker/loader
Linker/loader code
Dynamicallymapped code
(30)
The Computing Model Revisited
0xFFFFFFFF
Arithmetic Logic Unit (ALU)
0x000x010x02
0x03
0x1FProcessor Internal Buses
Memory InterfaceRegister File (Programmer Visible State)
stack
Data segment(static)
Text Segment
Dynamic Data
Reserved
Program Counter
Programmer Invisible State
Kernelregisters Program Execution and the von Neumann model
Memory MapInstruction register
0x0FFFFFFC
0x0400000
(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)
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 jal encodings for independently
compiled modules
(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