Assemblers Linkers and Loaders Hakim Weatherspoon CS 3410

Assemblers, Linkers, and Loaders Hakim Weatherspoon CS 3410, Spring 2013 Computer Science Cornell University See: P&H Appendix B. 3 -4 and 2. 12

Goal for Today: Putting it all Together Review Calling Convention Compiler output is assembly files Assembler output is obj files Linker joins object files into one executable Loader brings it into memory and starts execution

Recap: Calling Conventions • • first four arg words passed in $a 0, $a 1, $a 2, $a 3 remaining arg words passed in parent’s stack frame return value (if any) in $v 0, $v 1 $fp stack frame at $sp – contains $ra (clobbered on JAL to sub-functions) – contains $fp – contains local vars (possibly clobbered by sub-functions) – contains extra arguments to sub-functions (i. e. argument “spilling) – contains space for first 4 arguments to sub-functions • callee save regs are preserved • caller save regs are not • Global data accessed via $gp $sp saved ra saved fp saved regs ($s 0. . . $s 7) locals outgoing args Warning: There is no one true MIPS calling convention. lecture != book != gcc != spim != web

r 0 r 1 r 2 r 3 r 4 r 5 r 6 r 7 r 8 r 9 r 10 r 11 r 12 r 13 r 14 r 15 MIPS Register Conventions $zero $at assembler temp $v 0 function return values $v 1 $a 0 $a 1 function arguments $a 2 $a 3 $t 0 $t 1 $t 2 $t 3 temps $t 4 (caller save) $t 5 $t 6 $t 7 r 16 r 17 r 18 r 19 r 20 r 21 r 22 r 23 r 24 r 25 r 26 r 27 r 28 r 29 r 30 r 31 $s 0 $s 1 $s 2 $s 3 $s 4 $s 5 $s 6 $s 7 $t 8 $t 9 $k 0 $k 1 $gp $sp $fp $ra saved (callee save) more temps (caller save) reserved for kernel global data pointer stack pointer frame pointer return address

Anatomy of an executing program 0 xfffffffc top system reserved 0 x 80000000 0 x 7 ffffffc stack dynamic data (heap) 0 x 10000000 0 x 00400000 0 x 0000 static data code (text) . text system reserved bottom

Anatomy of an executing program +4 A alu D D $0 (zero) $1 ($at) register file $29 ($sp) $31 ($ra) memory IF/ID ID/EX forward unit Execute Stack, Data, Code Stored in Memory EX/MEM Memory ctrl Instruction Decode Instruction Fetch ctrl detect hazard dout memory ctrl imm extend new pc din B control M addr inst PC compute jump/branch targets B Code Stored in Memory (also, data and stack) Write. Back MEM/WB

Takeaway We need a calling convention to coordinate use of registers and memory. Registers exist in the Register File. Stack, Code, and Data exist in memory. Both instruction memory and data memory accessed through cache (modified harvard architecture) and a shared bus to memory (Von Neumann).

Next Goal Given a running program (a process), how do we know what is going on (what function is executing, what arguments were passed to where, where is the stack and current stack frame, where is the code and data, etc)?

Activity #1: Debugging init(): 0 x 400000 printf(s, …): 0 x 4002 B 4 vnorm(a, b): 0 x 40107 C main(a, b): 0 x 4010 A 0 pi: 0 x 10000000 str 1: 0 x 10000004 What func is running? Who called it? Has it called anything? Will it? Args? Stack depth? Call trace? CPU: $pc=0 x 004003 C 0 $sp=0 x 7 FFFFFAC $ra=0 x 00401090 0 x 0000 0 x 0040010 c 0 x 7 FFFFFF 4 0 x 00000000 0 x 004010 c 4 0 x 7 FFFFFDC 0 x 00000000 0 x 00000015 0 x 7 FFFFFB 0 0 x 10000004 0 x 00401090

Compilers and Assemblers

Next Goal How do we compile a program from source to assembly to machine object code?

Big Picture Compiler output is assembly files Assembler output is obj files Linker joins object files into one executable Loader brings it into memory and starts execution

Example: Add 1 to 100 int n = 100; int main (int argc, char* argv[ ]) { int i; int m = n; int sum = 0; for (i = 1; i <= m; i++) count += i; printf ("Sum 1 to %d is %dn", n, sum); } export PATH=${PATH}: /courses/cs 3410/mipsel-linux/bin: /courses/cs 3410/mips-sim/bin or setenv PATH ${PATH}: /courses/cs 3410/mipsel-linux/bin: /courses/cs 3410/mips-sim/bin # Assemble [csug 03] mipsel-linux-gcc –S add 1 To 100. c

Example: Add 1 to 100 . data. globl. align n: . word. rdata. align $str 0: . asciiz "Sum. text. align. globl main: addiu sw sw move sw sw la lw sw sw li sw n 2 100 $L 2: 2 1 to %d is %dn" 2 main $sp, -48 $31, 44($sp) $fp, 40($sp) $fp, $sp $4, 48($fp) $5, 52($fp) $2, n $2, 0($2) $2, 28($fp) $0, 32($fp) $2, 1 $2, 24($fp) $L 3: lw lw slt bne lw lw addu sw lw addiu sw b la lw lw jal move lw lw addiu $2, 24($fp) $3, 28($fp) $2, $3, $2 $2, $0, $L 3 $3, 32($fp) $2, 24($fp) $2, $3, $2 $2, 32($fp) $2, 24($fp) $2, 1 $2, 24($fp) $L 2 $4, $str 0 $5, 28($fp) $6, 32($fp) printf $sp, $fp $31, 44($sp) $fp, 40($sp) $sp, 48

Example: Add 1 to 100 # Assemble [csug 01] mipsel-linux-gcc –c add 1 To 100. s # Link [csug 01] mipsel-linux-gcc –o add 1 To 100. o ${LINKFLAGS} # -nostartfiles –nodefaultlibs # -static -mno-xgot -mno-embedded-pic -mno-abicalls -G 0 -DMIPS -Wall # Load [csug 01] simulate add 1 To 100 Sum 1 to 100 is 5050 MIPS program exits with status 0 (approx. 2007 instructions in 143000 nsec at 14. 14034 MHz)

Globals and Locals Variables Visibility Lifetime Location Function-Local Global Dynamic int n = 100; int main (int argc, char* argv[ ]) { int i, m = n, sum = 0, *A = malloc(4 * m); for (i = 1; i <= m; i++) { sum += i; A[i] = sum; } printf ("Sum 1 to %d is %dn", n, sum); }

Globals and Locals Variables Visibility Lifetime Function-Local w/in func invocation stack whole prgm execution . data Anywhere that b/w malloc C Pointers can be trouble has a ptr and free heap i, m, sum Global n, str Dynamic A Location

Example #2: Review of Program Layout calc. c vector* v = malloc(8); v->x = prompt(“enter x”); v->y = prompt(“enter y”); int c = pi + tnorm(v); print(“result %d”, c); system reserved stack math. c int tnorm(vector* v) { return abs(v->x)+abs(v->y); } lib 3410. o global variable: pi entry point: prompt entry point: print entry point: malloc dynamic data (heap) static data code (text) system reserved

Assembler calc. c calc. s calc. o math. c math. s math. o C source files Compiler io. s assembly files io. o libc. o executable program calc. exe exists on disk loader libm. o Executing obj files in Assembler linker Memory process

Next Goal How do we understand the machine object code that an assembler creates?

Big Picture math. c math. s math. o = Linux. obj Windows Output is obj files • Binary machine code, but not executable • May refer to external symbols i. e. Need a “symbol table” • Each object file has illusion of its own address space – Addresses will need to be fixed later e. g. . text (code) starts at addr 0 x 0000. data starts @ addr 0 x 0000

Symbols and References Global labels: Externally visible “exported” symbols • Can be referenced from other object files • Exported functions, global variables e. g. pi (from a couple of slides ago) Local labels: Internal visible only symbols • Only used within this object file • static functions, static variables, loop labels, … e. g. static foo static bar static baz e. g. $str $L 0 $L 2

Object file Header • Size and position of pieces of file Text Segment Object File • instructions Data Segment • static data (local/global vars, strings, constants) Debugging Information • line number code address map, etc. Symbol Table • External (exported) references • Unresolved (imported) references

math. c Example int pi = 3; int e = 2; static int randomval = 7; extern char *username; extern int printf(char *str, …); int square(int x) { … } static int is_prime(int x) { … } int pick_prime() { … } int pick_random() { return randomval; }

Objdump disassembly csug 01 ~$ mipsel-linux-objdump --disassemble math. o: file format elf 32 -tradlittlemips Disassembly of section. text: 0000 <pick_random>: 0: 27 bdfff 8 addiu 4: afbe 0000 sw 8: 03 a 0 f 021 move c: 3 c 020000 lui 10: 8 c 420008 lw 14: 03 c 0 e 821 move 18: 8 fbe 0000 lw 1 c: 27 bd 0008 addiu 20: 03 e 00008 jr 24: 0000 nop 00000028 <square>: 28: 27 bdfff 8 2 c: afbe 0000 30: 03 a 0 f 021 34: afc 40008 addiu sw move sw sp, -8 s 8, 0(sp) s 8, sp v 0, 0 x 0 v 0, 8(v 0) sp, s 8, 0(sp) sp, 8 ra sp, -8 s 8, 0(sp) s 8, sp a 0, 8(s 8)

Objdump symbols csug 01 ~$ mipsel-linux-objdump --syms math. o: file format elf 32 -tradlittlemips SYMBOL TABLE: 00000000 l 0000 l 00000008 l 00000060 l 00000000 l 0000 g 00000004 g 00000028 g 00000088 g 00000000 df d d O F d d O O F F F *ABS*. text. data. bss. mdebug. abi 32. data. text. rodata. comment. data. text *UND* 00000000 00000004 00000028 000000004 00000028 00000038 0000004 c 00000000 math. c. text. data. bss. mdebug. abi 32 randomval is_prime. rodata. comment pi e pick_random square pick_prime username printf

Separate Compilation Q: Why separate compile/assemble and linking steps? A: Can recompile one object, then just relink.

Takeaway We need a calling convention to coordinate use of registers and memory. Registers exist in the Register File. Stack, Code, and Data exist in memory. Both instruction memory and data memory accessed through cache (modified harvard architecture) and a shared bus to memory (Von Neumann). Need to compile from a high level source language to assembly, then assemble to machine object code. The Objdump command can help us understand structure of machine code which is broken into hdr, txt and data segments, debugging information, and symbol table

Linkers

Next Goal How do we link together separately compiled and assembled machine object files?

Big Picture calc. c calc. s calc. o math. c math. s math. o io. s calc. exe io. o libc. o libm. o linker Executing in Memory

Linkers Linker combines object files into an executable file • Relocate each object’s text and data segments • Resolve as-yet-unresolved symbols • Record top-level entry point in executable file End result: a program on disk, ready to execute • E. g. . /calc. exe simulate calc Linux Windows Class MIPS simulator

Relocation info Symbol tbl . text main. o. . . 0 C 000000 21035000 1 b 80050 C 4 C 040000 21047002 0 C 000000. . . 00 T main 00 D uname *UND* printf *UND* pi 40, JL, printf 4 C, LW/gp, pi 54, JL, square Linker Example math. o . . . 21032040 0 C 000000 1 b 301402 3 C 040000 34040000. . . 20 T square 00 D pi *UND* printf *UND* uname 28, JL, printf 30, LUI, uname 34, LA, uname printf. o. . . 3 C T printf

Linker Example main. o. . . 0 C 000000 21035000 1 b 80050 C 4 C 040000 21047002 0 C 000000. . . calc. exe math. o 2 00 T main B 00 D uname *UND* printf *UND* pi 40, JL, printf 4 C, LW/gp, pi 54, JL, square . . . 21032040 0 C 000000 1 b 301402 1 3 C 040000 34040000. . . 20 T square A 00 D pi *UND* printf *UND* uname 28, JL, printf 30, LUI, uname 34, LA, uname printf. o. . . 3 C T printf 3 . . . 21032040 0 C 40023 C 1 b 301402 1 3 C 041000 34040004. . . 0 C 40023 C 21035000 1 b 80050 c 2 4 C 048004 21047002 0 C 400020. . . 10201000 21040330 3 22500102. . . uname 00000003 pi 0077616 B Entry: 0040 0100 text: 0040 0000 data: 1000 0000

Header Object file • location of main entry point (if any) Text Segment Object File • instructions Data Segment • static data (local/global vars, strings, constants) Relocation Information • Instructions and data that depend on actual addresses • Linker patches these bits after relocating segments Symbol Table • Exported and imported references

Object File Formats Unix • • a. out COFF: Common Object File Format ELF: Executable and Linking Format … Windows • PE: Portable Executable All support both executable and object files

Recap Compiler output is assembly files Assembler output is obj files Linker joins object files into one executable Loader brings it into memory and starts execution

Administrivia Upcoming agenda • Schedule PA 2 Design Doc Mtg for next Monday, Mar 11 th • HW 3 due next Wednesday, March 13 th • PA 2 Work-in-Progress circuit due before spring break • Spring break: Saturday, March 16 th to Sunday, March 24 th • Prelim 2 Thursday, March 28 th, right after spring break • PA 2 due Thursday, April 4 th