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 2004 -03 -05 Roy Wang inst. eecs. berkeley. edu/~cs 61 c-tf CS 61 C L 14 Introduction to MIPS: Instruction Representation II (1) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (2) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (3) Garcia, Spring 2004 © 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 CS 61 C L 14 Introduction to MIPS: Instruction Representation II (4) a. out Relocated text 1 Relocated text 2 Relocated data 1 Relocated data 2 Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (5) Garcia, Spring 2004 © UCB

Four Types of Addresses • 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 14 Introduction to MIPS: Instruction Representation II (6) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (8) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (9) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (10) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (11) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (12) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (13) Garcia, Spring 2004 © UCB

Reading Quiz • K&R talks about the C preprocessor, but Figure 3. 21 on doesn't mention it. What is the purpose of the C preprocessor? What language is its input ? What is its output? If it were a separate step, where would it be placed relative to the other 4 steps? C program: foo. c Compiler Assembly program: foo. s Assembler • Object(mach lang module): foo. o Some earlier computers combined the first three steps into one, with the Linker lib. o compiler performing all the work of the assembler and linker. What would be the Executable(mach lang pgm): a. out impact on the C programmer if this were the case? Loader Memory CS 61 C L 14 Introduction to MIPS: Instruction Representation II (14) Garcia, Spring 2004 © UCB

Example: C Asm Obj Exe Run #include <stdio. h> int main (int argc, char *argv[]) { int i; int sum = 0; for (i = 0; i <= 100; i = i + 1) sum = sum + i * i; printf ("The sum from 0. . 100 is %dn", sum); } CS 61 C L 14 Introduction to MIPS: Instruction Representation II (15) Garcia, Spring 2004 © 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 j $ra Where are. data 7 pseudo. align 0 instructions? str: . asciiz "The sum from 0. . 100 is %dn" CS 61 C L 14 Introduction to MIPS: Instruction Representation II (16) Garcia, Spring 2004 © 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 j $ra 7 pseudo. data instructions. align 0 underlined str: . asciiz "The sum from 0. . 100 is %dn" CS 61 C L 14 Introduction to MIPS: Instruction Representation II (17) Garcia, Spring 2004 © UCB

Symbol Table Entries • Symbol Table Label Address main: loop: ? str: printf: • Relocation Table Address Instr. Type Dependency CS 61 C L 14 Introduction to MIPS: Instruction Representation II (18) Garcia, Spring 2004 © 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 CS 61 C L 14 Introduction to MIPS: Instruction Representation II (19) addiu sw slti bne lui ori lw jal add lw addiu jr $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, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (20) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (21) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (22) Garcia, Spring 2004 © UCB

Peer Instruction 2 (if time) • Which of the advantages of an interpreter over a translator do you think was most important for the designers of Java? A. Ease of writing an Interpreter B. Better error messages C. Smaller object code D. Machine independence CS 61 C L 14 Introduction to MIPS: Instruction Representation II (23) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (24) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (25) Garcia, Spring 2004 © 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 14 Introduction to MIPS: Instruction Representation II (26) Garcia, Spring 2004 © UCB