inst eecs berkeley educs 61 c CS 61

inst. eecs. berkeley. edu/~cs 61 c CS 61 C : Machine Structures Lecture 19 – Running a Program II aka Compiling, Assembling, Linking, Loading (CALL) Lecturer PSOE Dan Garcia www. cs. berkeley. edu/~ddgarcia Napster NOT hacked Actually, it was that they figured out how to download the stream into a file (ala putting a mike to the speakers) with no quality loss. Users/Napster happy. Apple? : ( www. techreview. com/articles/05/02/wo/wo_hellweg 021805. asp CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (1) Garcia 2005 © UCB

Where Are We Now? C program: foo. c Compiler Assembly program: foo. s Assembler Object(mach lang module): foo. o Linker lib. o Executable(mach lang pgm): a. out Loader Memory CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (2) Garcia 2005 © UCB

Link Editor/Linker (1/3) • Input: Object Code, information tables (e. g. , foo. o for MIPS) • Output: Executable Code (e. g. , a. out for MIPS) • Combines several object (. o) files into a single executable (“linking”) • Enable Separate Compilation of files • Changes to one file do not require recompilation of whole program - Windows NT source is >40 M lines of code! • Link Editor name from editing the “links” in jump and link instructions CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (3) Garcia 2005 © UCB

Link Editor/Linker (2/3). o file 1 text 1 data 1 info 1 Linker. o file 2 text 2 data 2 info 2 a. out Relocated text 1 Relocated text 2 Relocated data 1 Relocated data 2 CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (4) Garcia 2005 © UCB

Link Editor/Linker (3/3) • Step 1: Take text segment from each. o file and put them together. • Step 2: Take data segment from each. o file, put them together, and concatenate this onto end of text segments. • Step 3: Resolve References • Go through Relocation Table and handle each entry • That is, fill in all absolute addresses CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (5) Garcia 2005 © UCB

Four Types of Addresses we’ll discuss • PC-Relative Addressing (beq, bne): never relocate • Absolute Address (j, jal): always relocate • External Reference (usually jal): always relocate • Data Reference (often lui and ori): always relocate CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (6) Garcia 2005 © UCB

Absolute Addresses in MIPS • Which instructions need relocation editing? • J-format: jump, jump and link j/jal xxxxx • Loads and stores to variables in static area, relative to global pointer lw/sw $gp $x address • What about conditional branches? beq/bne $rs $rt address • PC-relative addressing preserved even if code moves CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (7) Garcia 2005 © UCB

Resolving References (1/2) • Linker assumes first word of first text segment is at address 0 x 0000. • Linker knows: • length of each text and data segment • ordering of text and data segments • Linker calculates: • absolute address of each label to be jumped to (internal or external) and each piece of data being referenced CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (8) Garcia 2005 © UCB

Resolving References (2/2) • To resolve references: • search for reference (data or label) in all symbol tables • if not found, search library files (for example, for printf) • once absolute address is determined, fill in the machine code appropriately • Output of linker: executable file containing text and data (plus header) CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (9) Garcia 2005 © UCB

Static vs Dynamically linked libraries • What we’ve described is the traditional way to create a static-linked approach • The library is now part of the executable, so if the library updates we don’t get the fix (have to recompile if we have source) • In includes the entire library even if not all of it will be used. • An alternative is dynamically linked libraries (DLL), common on Windows & UNIX platforms • 1 st run overhead for dynamic linker-loader • Having executable isn’t enough anymore! CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (10) Garcia 2005 © UCB

Where Are We Now? C program: foo. c Compiler Assembly program: foo. s Assembler Object(mach lang module): foo. o Linker lib. o Executable(mach lang pgm): a. out Loader Memory CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (11) Garcia 2005 © UCB

Loader (1/3) • Input: Executable Code (e. g. , a. out for MIPS) • Output: (program is run) • Executable files are stored on disk. • When one is run, loader’s job is to load it into memory and start it running. • In reality, loader is the operating system (OS) • loading is one of the OS tasks CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (12) Garcia 2005 © UCB

Loader (2/3) • So what does a loader do? • Reads executable file’s header to determine size of text and data segments • Creates new address space for program large enough to hold text and data segments, along with a stack segment • Copies instructions and data from executable file into the new address space (this may be anywhere in memory) CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (13) Garcia 2005 © UCB

Loader (3/3) • Copies arguments passed to the program onto the stack • Initializes machine registers • Most registers cleared, but stack pointer assigned address of 1 st free stack location • Jumps to start-up routine that copies program’s arguments from stack to registers and sets the PC • If main routine returns, start-up routine terminates program with the exit system call CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (14) Garcia 2005 © UCB

Administrivia • Review session 10 Evans Sun 2 pm • Midterm Exam 1 Le Conte Mon 7 -10 pm • DSP/Conflict students -- talk to Andy • HKN/UPE holding study session immediately Sun after review session • 5: 30 PM - 8: 00 PM Wozniak Lounge • Work/read/etc with former 61 C students available for help CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (15) Garcia 2005 © UCB

Example: C Asm Obj Exe Run #include <stdio. h> int main (int argc, char *argv[]) { int i, sum = 0; for (i = 0; i <= 100; i++) sum = sum + i * i; printf ("The sum from 0. . 100 is %dn", sum); } CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (16) Garcia 2005 © UCB

Example: C Asm Obj Exe Run. text. align 2. globl main: subu $sp, 32 sw $ra, 20($sp) sd $a 0, 32($sp) sw $0, 24($sp) sw $0, 28($sp) loop: lw $t 6, 28($sp) mul $t 7, $t 6 lw $t 8, 24($sp) addu $t 9, $t 8, $t 7 sw $t 9, 24($sp) addu $t 0, $t 6, 1 sw $t 0, 28($sp) ble $t 0, 100, loop la $a 0, str lw $a 1, 24($sp) jal printf move $v 0, $0 lw $ra, 20($sp) addiu $sp, 32 jr $ra Where are. data 7 pseudo. align 0 instructions? str: . asciiz "The sum from 0. . 100 is %dn" CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (17) Garcia 2005 © UCB

Example: C Asm Obj Exe Run. text. align 2. globl main: subu $sp, 32 sw $ra, 20($sp) sd $a 0, 32($sp) sw $0, 24($sp) sw $0, 28($sp) loop: lw $t 6, 28($sp) mul $t 7, $t 6 lw $t 8, 24($sp) addu $t 9, $t 8, $t 7 sw $t 9, 24($sp) addu $t 0, $t 6, 1 sw $t 0, 28($sp) ble $t 0, 100, loop la $a 0, str lw $a 1, 24($sp) jal printf move $v 0, $0 lw $ra, 20($sp) addiu $sp, 32 jr $ra 7 pseudo. data instructions. align 0 underlined str: . asciiz "The sum from 0. . 100 is %dn" CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (18) Garcia 2005 © UCB

Symbol Table Entries • Symbol Table Label Address main: loop: ? str: printf: • Relocation Table Address Instr. Type Dependency CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (19) Garcia 2005 © UCB

Example: C Asm Obj Exe Run • Remove pseudoinstructions, assign addresses 00 04 08 0 c 10 14 18 1 c 20 24 28 2 c addiu $29, -32 sw $31, 20($29) sw $4, 32($29) sw $5, 36($29) sw $0, 24($29) sw $0, 28($29) lw $14, 28($29) multu $14, $14 mflo $15 lw $24, 24($29) addu $25, $24, $15 sw $25, 24($29) 30 34 38 3 c 40 44 48 4 c 50 54 58 5 c addiu sw slti bne lui ori lw jal add lw addiu jr CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (20) $8, $14, 1 $8, 28($29) $1, $8, 101 $1, $0, loop $4, l. str $4, r. str $5, 24($29) printf $2, $0 $31, 20($29) $29, 32 $31 Garcia 2005 © UCB

Symbol Table Entries • Symbol Table • Label Address main: 0 x 0000 loop: 0 x 00000018 str: 0 x 10000430 printf: 0 x 000003 b 0 • Relocation Information • Address 0 x 00000040 0 x 00000044 0 x 0000004 c Instr. Type. Dependency lui l. str ori r. str jal printf CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (21) Garcia 2005 © UCB

Example: C Asm Obj Exe Run • Edit Addresses: start at 0 x 0040000 00 addiu $29, -32 30 addiu $8, $14, 1 04 sw $31, 20($29) 34 sw $8, 28($29) 08 sw $4, 32($29) 38 slti $1, $8, 101 0 c sw $5, 36($29) 3 c bne $1, $0, -10 10 sw $0, 24($29) 40 lui $4, 4096 14 sw $0, 28($29) 44 ori $4, 1072 18 lw $14, 28($29) 48 lw $5, 24($29) 1 c multu $14, $14 4 c jal 812 20 mflo $15 50 add $2, $0 24 lw $24, 24($29) 54 lw $31, 20($29) 28 addu $25, $24, $15 58 addiu $29, 32 2 c sw $25, 24($29) 5 c jr $31 CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (22) Garcia 2005 © UCB

Example: C Asm Obj Exe Run 0 x 004000 0 x 004004 0 x 004008 0 x 00400 c 0 x 004010 0 x 004014 0 x 004018 0 x 00401 c 0 x 004020 0 x 004024 0 x 004028 0 x 00402 c 0 x 004030 0 x 004034 0 x 004038 0 x 00403 c 0 x 004040 0 x 004044 0 x 004048 0 x 00404 c 0 x 004050 0 x 004054 0 x 004058 0 x 00405 c 001001111011111100000 101011111100000010100 10101111101001000000100000 10101111101000000100100 101011111010000000011000 101011111010000000011100 10001111101011100000011100 1000111110000000011000 000000011100000011001 00100101110010000000001 001010010000000001100101 1010111110101000000011100 000000000111100000010010 0000001111110010000101000001111110111 10101111100100000011000 00111100000001000000 1000111110100000001100000000000011101100 0010010010000000110000 100011111100000010100 00100111101000001000000111110000000001000 000000000010000001 CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (23) Garcia 2005 © UCB

Peer Instruction Which of the following instr. may need to be edited during link phase? Loop: lui ori jal bne $at, 0 x. ABCD # A } $a 0, $at, 0 x. FEDC add_link # B $a 0, $v 0, Loop # C CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (24) 1: 2: 3: 4: 5: 6: 7: 8: ABC FFF FFT FTF FTT TFF TFT TTF TTT Garcia 2005 © UCB

Peer Instruction Answer Which of the following instr. may need to be edited during link phase? Loop: lui ori jal bne data reference; relocate $at, 0 x. ABCD # A } $a 0, $at, 0 x. FEDC subroutine; relocate add_link # B PC-relative branch; OK $a 0, $v 0, Loop # C CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (25) 1: 2: 3: 4: 5: 6: 7: 8: ABC FFF FFT FTF FTT TFF TFT TTF TTT Garcia 2005 © UCB

Things to Remember (1/3) C program: foo. c Compiler Assembly program: foo. s Assembler Object(mach lang module): foo. o Linker lib. o Executable(mach lang pgm): a. out Loader Memory CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (26) Garcia 2005 © UCB

Things to Remember (2/3) • Compiler converts a single HLL file into a single assembly language file. • Assembler removes pseudoinstructions, converts what it can to machine language, and creates a checklist for the linker (relocation table). This changes each. s file into a. o file. • Linker combines several. o files and resolves absolute addresses. • Loader loads executable into memory and begins execution. CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (27) Garcia 2005 © UCB

Things to Remember 3/3 • Stored Program concept mean instructions just like data, so can take data from storage, and keep transforming it until load registers and jump to routine to begin execution • Compiler Assembler Linker ( Loader ) • Assembler does 2 passes to resolve addresses, handling internal forward references • Linker enables separate compilation, libraries that need not be compiled, and resolves remaining addresses CS 61 C L 19 Running a Program aka Compiling, Assembling, Loading, Linking (CALL) II (28) Garcia 2005 © UCB