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 A: A1 - A.6 ( in online text)
Practice Problems: 10, 14,23
Goals
Understand the binary encoding of complete program executables
How can procedures be independently compiled and linked (e.g., libraries)?
What makes up an executable?
How do libraries become part of the executable?
What is the role of the ISA in encoding programs?
What constitutes the hardware/software interface

4. Procedure Calls Basic functionality What is so hard about this?
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 Nested procedures
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
.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: ---
Register usage
What about nested calls?
What about excess arguments? PC + 4
$31 PC
$31

7. Leaf Procedure Example
The University of Adelaide, School of Computer Science
22 June 2018
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
result registers
$v0
$v1
argument registers
procedure
Chapter 2 — Instructions: Language of the Computer

8. Procedure Call Instructions
The University of Adelaide, School of Computer Science
22 June 2018
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
e.g., for case/switch statements
Example:
Chapter 2 — Instructions: Language of the Computer

9. Leaf Procedure Example
The University of Adelaide, School of Computer Science
22 June 2018
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
Result
Restore $s0
Return
Chapter 2 — Instructions: Language of the Computer

10. Procedure Call Mechanics
High Address
System Wide Memory Map
$fp
$sp
Old Stack Frame
stack
$sp
$fp
arg registers
dynamic data
return address
$gp
static data
New Stack
Frame
Saved registers
text PC
local variables
reserved
$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
$s0-$s9
4. allocate stack frame
5. save callee save registers
($s0-$s9, $fp, $ra)
caller
saved
registers
$a0-$a3
$t0-$t9
6 set frame pointer
Return
local
variables
1. place function argument in $v0
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
The University of Adelaide, School of Computer Science
22 June 2018
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)
Chapter 2 — Instructions: Language of the Computer

14. The University of Adelaide, School of Computer Science
22 June 2018
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
Chapter 2 — Instructions: Language of the Computer

15. Non-Leaf Procedure Example
The University of Adelaide, School of Computer Science
22 June 2018
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
Chapter 2 — Instructions: Language of the Computer

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
The University of Adelaide, School of Computer Science
22 June 2018
Non-Leaf Procedure Example
int fact (int n) { callee save
if (n < 1)
return f; else
return n * fact(n - 1); restore }
Chapter 2 — Instructions: Language of the Computer

18. Non-Leaf Procedure Example
The University of Adelaide, School of Computer Science
22 June 2018
Non-Leaf Procedure Example
MIPS code:
fact: addi $sp, $sp, # adjust stack for 2 items sw $ra, 4($sp) # save return address sw $a0, 0($sp) # save argument slti $t0, $a0, # test for n < beq $t0, $zero, L1 addi $v0, $zero, 1 # if so, result is addi $sp, $sp, # pop 2 items from stack jr $ra # and return L1: addi $a0, $a0, # else decrement n jal fact # recursive call lw $a0, 0($sp) # restore original n lw $ra, 4($sp) # and return address addi $sp, $sp, # pop 2 items from stack mul $v0, $a0, $v0 # multiply to get result jr $ra # and return
Callee save
Termination Check
Leaf Node
Recursive call
Intermediate Node
Chapter 2 — Instructions: Language of the Computer

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, A2, A3, A4, A5 C program compiler
Assembly
assembler
Object module
Object library
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
Relocation information
Symbol table
Example:

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 .data What changes when you relocate code?
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
What changes when you relocate code?
] 3c lui $8, 4097 [L1]         [ ] ori $9, $0, 4            
[ ] add $10, $10, $0          [ c] 8d0b0000 lw $11, 0($8)             [ ] 014b5020 add $10, $10, $11         [ ] addi $8, $8, 4            [ ] 2129ffff   addi $9, $9, -1           [ c] 1520fffc   bne $9, $0, -16 [loop-0x c] [ ] 000a082a slt $1, $0, $10           [ ] bne $1, $0, 12 [then-0x ] [ ] 000a8021 addu $16, $0, $10         [ c] d j 0x [exit]       [ ] 000a8821 addu $17, $0, $10        [ ] a ori $2, $0, 10           [ ] c syscall
Assembly Program
Native Instructions
Assembled Binary

24. Linker & Loader Linker Loader “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 Assembly A Assembly B cross reference
header
text
static data
Assembly A
Assembly B
reloc
cross reference
symbol table
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. 127

26. Example: # separate file .text 0x20040004 addi $4, $0, 4 0x20050005
jal func_add
done 0x a
0x c
.text
.globl func_add
func_add: add $2, $4, $5 0x
jr $ x03e00008
0x x
0x x
0x ?
0x c 0x a
0x x c
0x x
0x x03e00008
Ans: 0x0c100005

27. The University of Adelaide, School of Computer Science
22 June 2018
Loading a Program
Load from image file on disk into memory
1. Read header to determine segment sizes
2. Create virtual address space (later)
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
Chapter 2 — Instructions: Language of the Computer

28. The University of Adelaide, School of Computer Science
22 June 2018
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
Chapter 2 — Instructions: Language of the Computer

29. The University of Adelaide, School of Computer Science
22 June 2018
Lazy Linkage
Indirection table
Stub: Loads routine ID, Jump to linker/loader
Linker/loader code
Dynamically mapped code
Chapter 2 — Instructions: Language of the Computer

30. Standard Formats: ELF Executable and Linking Format (ELF) ELF header
Program Header Table (optional)
Section 1
Section 2
Section Header Table (required)
ELF header
Program Header Table (required)
Segment 1
Segment 2
Section Header Table (optional)
Linking View
Execution View
See wikipedia.org

31. Standard Object File Formats
There are other formats associated with different operating systems
ISA neutral format for building executables
Tools
Source  assembly  object  executable  process image

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

33. Instruction Set Architectures (ISA)
Instruction set architectures are characterized by several features
Operations
Types, precision, size
Organization of internal storage
Stack machine
Accumulator
General Purpose Registers (GPR)
Memory addressing
Operand location and addressing

34. Instruction Set Architectures
Memory abstractions
Segments, virtual address spaces (more later)
Memory mapped I/O (later)
Control flow
Condition codes
Types of control transfers – conditional vs. unconditiional
ISA design is the result of many tradeoffs
Decisions determine hardware implementation
Impact on time, space, and energy
Check out ISAs for PowerPC, ARM, x86, SPARC, etc.

35. ARM & MIPS Similarities
The University of Adelaide, School of Computer Science
22 June 2018
ARM & MIPS Similarities
ARM: the most popular embedded core
Similar basic set of instructions to MIPS
ARM
MIPS
Date announced
1985
Instruction size
32 bits
Address space
32-bit flat
Data alignment
Aligned
Data addressing modes 9 3
Registers
15 × 32-bit
31 × 32-bit
Input/output
Memory mapped
Chapter 2 — Instructions: Language of the Computer

36. Compare and Branch in ARM
The University of Adelaide, School of Computer Science
22 June 2018
Compare and Branch in ARM
Uses condition codes for result of an arithmetic/logical instruction
Negative, zero, carry, overflow
Compare instructions to set condition codes without keeping the result
Each instruction can be conditional
Top 4 bits of instruction word: condition value
Can avoid branches over single instructions
ALU $0 $1
$31
CPU/Core Z V C N
Chapter 2 — Instructions: Language of the Computer

37. The University of Adelaide, School of Computer Science
22 June 2018
Instruction Encoding
Differences?
Chapter 2 — Instructions: Language of the Computer

38. The University of Adelaide, School of Computer Science
22 June 2018
The Intel x86 ISA
Evolution with backward compatibility
8080 (1974): 8-bit microprocessor
Accumulator, plus 3 index-register pairs
8086 (1978): 16-bit extension to 8080
Complex instruction set (CISC)
8087 (1980): floating-point coprocessor
Adds FP instructions and register stack
80286 (1982): 24-bit addresses, MMU
Segmented memory mapping and protection
80386 (1985): 32-bit extension (now IA-32)
Additional addressing modes and operations
Paged memory mapping as well as segments
Chapter 2 — Instructions: Language of the Computer

39. The University of Adelaide, School of Computer Science
22 June 2018
The Intel x86 ISA
Further evolution…
i486 (1989): pipelined, on-chip caches and FPU
Pentium (1993): superscalar, 64-bit datapath
Later versions added MMX (Multi-Media eXtension) instructions
The infamous FDIV bug
Pentium Pro (1995), Pentium II (1997)
New microarchitecture (see Colwell, The Pentium Chronicles)
Pentium III (1999)
Added SSE (Streaming SIMD Extensions) and associated registers
Pentium 4 (2001)
New microarchitecture
Added SSE2 instructions
Chapter 2 — Instructions: Language of the Computer

40. The University of Adelaide, School of Computer Science
22 June 2018
The Intel x86 ISA
And further…
AMD64 (2003): extended architecture to 64 bits
EM64T – Extended Memory 64 Technology (2004)
AMD64 adopted by Intel (with refinements)
Added SSE3 instructions
Intel Core (2006)
Added SSE4 instructions, virtual machine support
AMD64 (announced 2007): SSE5 instructions
Intel Advanced Vector Extension (AVX announced 2008)
If Intel didn’t extend with compatibility, its competitors would!
Technical elegance ≠ market success
Commonly thought of as a Complex Instruction Set Architecture (CISC)
Chapter 2 — Instructions: Language of the Computer

41. The University of Adelaide, School of Computer Science
22 June 2018
Basic x86 Registers
Chapter 2 — Instructions: Language of the Computer

42. Basic x86 Addressing Modes
The University of Adelaide, School of Computer Science
22 June 2018
Basic x86 Addressing Modes
Two operands per instruction
Source/dest operand
Second source operand
Register
Immediate
Memory
Memory addressing modes
Address in register
Address = Rbase + displacement
Address = Rbase + 2scale × Rindex (scale = 0, 1, 2, or 3)
Address = Rbase + 2scale × Rindex + displacement
Chapter 2 — Instructions: Language of the Computer

43. x86 Instruction Encoding
The University of Adelaide, School of Computer Science
22 June 2018
x86 Instruction Encoding
Variable length encoding
Postfix bytes specify addressing mode
Prefix bytes modify operation
Operand length, repetition, locking, …
Chapter 2 — Instructions: Language of the Computer

44. The University of Adelaide, School of Computer Science
22 June 2018
Implementing IA-32
Complex instruction set makes implementation difficult
Hardware translates instructions to simpler microoperations
Simple instructions: 1–1
Complex instructions: 1–many
Microengine similar to RISC
Market share makes this economically viable
Comparable performance to RISC
Compilers avoid complex instructions
Better code density
Chapter 2 — Instructions: Language of the Computer

45. The University of Adelaide, School of Computer Science
22 June 2018
Fallacies
Powerful instruction  higher performance
Fewer instructions required
But complex instructions are hard to implement
May slow down all instructions, including simple ones
Compilers are good at making fast code from simple instructions
Use assembly code for high performance
But modern compilers are better at dealing with modern processors
More lines of code  more errors and less productivity
Chapter 2 — Instructions: Language of the Computer

46. The University of Adelaide, School of Computer Science
22 June 2018
Fallacies
Backward compatibility  instruction set does not change
But they do accrete more instructions
x86 instruction set
Chapter 2 — Instructions: Language of the Computer

47. Summary Instruction complexity is only one variable Design Principles:
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!

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

49. 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
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)

50. 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
Unresolved symbol