A SimplisHc Program TranslaHon Scheme. TranslaHng the Example Program. Example C Program. Why Linkers? - Modularity. Linking

Transcription

1 A SimplisHc Program TranslaHon Scheme Linking ASCII (Text) source file The American Standard Code for InformaHon Interchange (ASCII) CSCI 221: Machine Architecture and OrganizaHon Pen- Chung Yew Department Computer Science and Engineering Translator p Binary executable object file (memory image on disk) University of Minnesota With Slides from Bryant, O Hallaron and Zhai Problems: Efficiency: small change requires complete recompilation Modularity: hard to share common functions (e.g. printf) Solution: Static linker (or linker) 3 Example C Program TranslaHng the Example Program int buf[2] = 1, 2; return ; int *bufp = &buf[]; temp = *bufp; *bufp = *bufp1; Compiler driver coordinates all steps in the translaon and linking process. Typically included with each compilaon system (e.g., gcc) Invokes preprocessor (cpp), compiler (cc1), assembler (as), and linker (ld). Passes command line arguments to appropriate phases Example: create executable p from and : Programs are translated and linked using a compiler driver: unix> gcc -O2 -g -o p unix>./p 4 5 StaHc (Compile- Time) Linking Why Linkers? - Modularity Programs are translated and linked using a compiler driver: unix> gcc -O2 -g -o p unix>./p Reason 1: Modularity Translators (cpp, cc1, as) main.o Linker (ld) Translators (cpp, cc1, as) swap.o Source files Separately compiled relocatable object files Program can be wriaen as a collecon of smaller source files, rather than one monolithic mass (needed for very large socware projects with millions lines of code). Can build libraries of common funcons (more on this later) e.g., Math library, standard C library p Fully linked executable object file (contains code and data for all func<ons defined in and ) 6 1 1

2 Why Linkers? Time & Space Efficiency Reason 2: Efficiency Time efficiency: Separate compilahon Change one source file, compile, and then relink. No need to recompile other source files. What Do Linkers Do? Symbol ResoluHon Step 1. Symbol resoluhon Programs define and reference symbols (variables and funchons): /* define symbol swap */ /* reference symbol swap */ int *xp = &x; /* define symbol xp, reference x */ Space efficiency: Libraries Common funcons can be aggregated into a single file. Yet executable files and running memory images contain only code for the funcons they actually use. 11 Symbol definihons are stored (by compiler) in symbol table. Symbol table is an array of structs Each entry includes name, size, and locahon of symbol. Linker associates each symbol reference with exactly one definihon. 12 What Do Linkers Do? - RelocaHon Step 2. RelocaHon Merges separate code and data secons into single secons Relocates symbols from their relahve locahons in.o files to their final absolute memory locahons in the executable. Updates all references to these symbols to reflect their new posions. Three Kinds of Object Files (Modules) Relocatable object file (.o file) Contains code and data in a form that can be combined with other relocatable object files to form executable object file. Each.o file is produced from exactly one source (.c) file Executable object file (a.out file) Contains code and data in a form that can be copied directly into memory and then executed. Shared object file (.so file) Special type of relocatable object file that can be loaded into memory and linked dynamically, at either load Hme or run- Hme. Called Dynamic Link Libraries (DLLs) by Windows Executable and Linkable Format (ELF) Standard binary format for object files Originally proposed by AT&T System V Unix Later adopted by BSD Unix variants and Linux One unified format for Relocatable object files (.o), Executable object files (a.out) Shared object files (.so) Generic name: ELF binaries 15 ELF Relocatable Object File Format Elf header Word size, byte ordering, file type (.o, a.out.so), machine type, etc. sechon Code Read only data: jump tables, print strings,... sechon Inialized global variables Uninialized global variables Block Started by Symbol or BeAer Save Space Has secon header but occupies no space Symbol table Procedure and stac variable names Secon names and locaons sechon sechon.rel sechon.rel sechon 16 2

3 ELF Relocatable Object File Format (cont.).rel sechon Relocaon info for secon Addresses of instrucons that will need to be modified in the executable Instrucons for modifying..rel sechon Relocaon info for secon Addresses of pointer data that will need to be modified in the merged executable Info for symbolic debugging (gcc g) Line number in C source code String table for symbol table section header table Offsets and sizes of each secon sechon sechon.rel sechon.rel sechon ELF Executable Object File Format Elf header Word size, byte ordering, file type (.o, a.out.so), machine type, etc. Segment header table Page size, virtual memory addresses of segments (secons), segment sizes..init section _init funcon called by inializaon sechon Code Read only data: jump tables, print strings,... sechon Inialized global variables Segment header table.init sechon sechon sechon ELF Executable Object File Format Uninialized global variables Block Started by Symbol or BeAer Save Space Has secon header but occupies no space Symbol table Procedure and stac variable names Secon names and locaons sechon Code Info for symbolic debugging (gcc g) Line number in C source code String table for symbol table section header table Offsets and sizes of each secon Segment header table.init sechon sechon sechon 19 Linker Symbols symbols Symbols defined by module m that can be referenced by other modules. E.g.: non- static C funcons and non- static global variables. External symbols symbols that are referenced by module m but defined by some other module. Local symbols Symbols that are defined and referenced exclusively by module m, i.e..c files. E.g.: C funcons and variables defined with static aaribute. Local linker symbols are NOT local program variables 2 Resolving Symbols int buf[2] = 1, 2; return ; External Linker knows nothing of temp int *bufp = &buf[]; External temp = *bufp; *bufp = *bufp1; Local 21 ELF Relocatable Object File Format Elf header Word size, byte ordering, file type (.o, a.out.so), machine type, etc. sechon Code Read only data: jump tables, print strings,... sechon Inialized global variables Uninialized global variables Block Started by Symbol or BeAer Save Space Has secon header but occupies no space Symbol table Procedure and stahc variable names SecHon names and locahons sechon sechon.rel sechon.rel sechon 22 3

4 ELF Symbol Table Entry Typedef struct int name; /* String table offset */ int value; /* Section offset, of VM address */ int size; /* Object size in bytes */ char type:4 /* Data, func, section, or src file name*/ binding: 4 /* or Local */ char reserved; /* Unused */ char section; /* Section header index, ABS, UNDEF, */ /* or COMMON (data not yet allocated) */ Elf_Symbol; /* each entry in.symtab section identifies */ 23 Resolving Symbols int buf[2] = 1, 2; return ; External Linker knows nothing of temp int *bufp = &buf[]; External temp = *bufp; *bufp = *bufp1; Local 24 ELF Symbol Table Entry RelocaHng Code and Data Through Linking Num: Value Size Type Bind Ndx Name 8: 8 Object 3 buf 9: 17 Func 1 main 1: Notype UND swap Symbol Table for main.o Num: Value Size Type Bind Ndx Name 8: 4 Object 3 bufp 9: Notype UND buf 1: 39 Func 1 swap 11: 4 4 Object COM bufp1 Symbol Table for swap.o Ndx: SecHon number Relocatable Object Files System code System data main.o main() int buf[2]=1,2 swap.o swap() int *bufp=&buf[] static int *bufp1.bss Executable Object File merging sechons in Relocatable object files Headers System code main() swap() More system code System data int buf[2]=1,2 int *bufp=&buf[] int *bufp1.symtab.debug.bss Even though private to swap, requires allocaon in.bss Virtual Memory of a Linux Process Three Kinds of Object Files (Modules) Different for each process IdenHcal for each process x848 (32) x4 (64) %esp brk Process- specific data structs (ptables, task and mm structs, kernel stack) Physical memory Kernel code and data User stack Memory mapped region for shared libraries RunHme heap (malloc) UniniHalized data (.bss) IniHalized data () Program text () Kernel virtual memory Process virtual memory 27 Relocatable object file (.o file) Contains code and data in a form that can be combined with other relocatable object files to form executable object file. Each.o file is produced from exactly one source (.c) file Executable object file (a.out file) Contains code and data in a form that can be copied directly into memory and then executed. Shared object file (.so file) Special type of relocatable object file that can be loaded into memory and linked dynamically, at either load Hme or run- Hme. Called Dynamic Link Libraries (DLLs) by Windows 32 4

5 RelocaHng Code and Data Through Linking Relocatable Object Files main.o swap.o System code System data main() int buf[2]=1,2 swap() int *bufp=&buf[] static int *bufp1.bss Executable Object File merging sechons in Relocatable object files Headers System code main() swap() More system code System data int buf[2]=1,2 int *bufp=&buf[] int *bufp1.symtab.debug Even though private to swap, requires allocaon in.bss.bss 33 Resolving Symbols int buf[2] = 1, 2; return ; External Linker knows nothing of temp int *bufp = &buf[]; External temp = *bufp; *bufp = *bufp1; Local 34 ELF Relocatable Object File Format Elf header Word size, byte ordering, file type (.o, a.out.so), machine type, etc. sechon Code Read only data: jump tables, print strings,... sechon Inialized global variables Uninialized global variables Block Started by Symbol or BeAer Save Space Has secon header but occupies no space Symbol table Procedure and stac variable names Secon names and locaons sechon sechon.rel sechon.rel sechon 35 ELF Relocatable Object File Format (cont.).rel sechon Relocaon info for secon Addresses of instrucons that will need to be modified in the executable Instrucons for modifying..rel sechon Relocaon info for secon Addresses of pointer data that will need to be modified in the merged executable Info for symbolic debugging (gcc g) Line number in C source code String table for symbol table section header table Offsets and sizes of each secon sechon sechon.rel sechon.rel sechon 36 ELF Symbol Table Entry ELF RelocaHon Entry Typedef struct int name; /* String table offset */ int value; /* Section offset, of VM address */ int size; /* Object size in bytes */ char type:4 /* Data, func, section, or src file name */ binding: 4 /* or Local */ char reserved; /* Unused */ char section; /* Section header index, ABS, UNDEF, */ /* or COMMON */ Elf_Symbol; /* each entry in.symtab section identifies */ Num: Value Size Type Bind Ndx Name 8: 8 Object 3 buf 9: 17 Func 1 main 1: Notype UND swap Typedef struct int offset; int symbol:24 /* Offset of the reference to relocate */ type: 8 /* Relocation type */ Elf32_Rel; /* each entry in.rel section identifies */ /* a reference that needs to be relocated */ q R_386_PC32: Relocate a reference that uses a 32-bit PC-relative address q R_386_32: Relocate a reference that uses a 32-bit absolute address Symbol Table for main.o Ndx: SecHon number

6 RelocaHon Info (main) int buf[2] = 1,2; return ; Source: objdump r d -r : display relocation entries -d : disassemble <main>: : 55 push %ebp 1: 89 e5 mov %esp,%ebp 3: 83 e4 f and $xfffffff,%esp 6: e8 fc ff ff ff call 7 <main+x7> 7: R_386_PC32 swap #relocation entry b: b8 mov $x,%eax 1: 89 ec mov %ebp,%esp 12: 5d pop %ebp 13: c3 ret <buf>: : 1 add %eax,(%eax) 2: add %al,(%eax) 4: 2 add (%eax),%al 6: add %al,(%eax) r.offset = x7 ; r.symbol = swap ; r.type = R_386_PC32 Ignore these 41 RelocaHon Info (swap, ) int *bufp = &buf[]; temp = *bufp; *bufp = *bufp1; swap.o Disassembly of section : <swap>: : 55 push %ebp 1: 89 e5 mov %esp,%ebp 3: 83 ec 1 sub $x1,%esp 6: c7 5 4 movl $x4,x d: 8: R_386_32.bss c: R_386_32 buf 1: a1 mov x,%eax 11: R_386_32 bufp 15: 8b mov (%eax),%eax 17: fc mov %eax,-x4(%ebp) 1a: a1 mov x,%eax 1b: R_386_32 bufp 1f: 8b 15 mov x,%edx 21: R_386_32.bss 25: 8b 12 mov (%edx),%edx 27: 89 1 mov %edx,(%eax) 29: a1 mov x,%eax 2a: R_386_32.bss 2e: 8b 55 fc mov -x4(%ebp),%edx 31: 89 1 mov %edx,(%eax) 33: c9 leave 34: c3 ret 42 RelocaHon Info (swap, ) Executable Before/Amer RelocaHon () int *bufp = &buf[]; temp = *bufp; *bufp = *bufp1; Disassembly of section : <bufp>: : add %al,(%eax)... Disassembly of section.bss: <bufp1>: : add %al,(%eax) int *bufp = &buf[]; temp = *bufp; *bufp = *bufp1; swap.o 8483a8: 55 push %ebp 8483a9: 89 e5 mov %esp,%ebp 8483ab: 83 ec 1 sub $x1,%esp 8483ae: c a movl $x84a14,x84a b5: a b8: a1 18 a 4 8 mov x84a18,%eax 8483bd: 8b mov (%eax),%eax 8483bf: fc mov %eax,-x4(%ebp) 8483c2: a1 18 a 4 8 mov x84a18,%eax 8483c7: 8b a 4 8 mov x84a24,%edx 8483cd: 8b 12 mov (%edx),%edx 8483cf: 89 1 mov %edx,(%eax) 8483d1: a1 24 a 4 8 mov x84a24,%eax 8483d6: 8b 55 fc mov -x4(%ebp),%edx 8483d9: 89 1 mov %edx,(%eax) 8483db: c9 leave Executable Before/Amer RelocaHon () Another Example main.o <main>: : 55 push %ebp : 89 e5 mov %esp,%ebp : 83 e4 f and $xfffffff,%esp 84839a: e8 9 call x8483a8 <swap> 84839f: b8 mov $x,%eax 8483a4: 89 ec mov %ebp,%esp 8483a6: 5d pop %ebp 8483a7: c3 ret int buf[2] = 1,2; return ; <main>: : 55 push %ebp 1: 89 e5 mov %esp,%ebp 3: 83 e4 f and $xfffffff,%esp 6: e8 fc ff ff ff call 7 <main+x7> 7: R_386_PC32 swap #relocation entry b: b8 mov $x,%eax 1: 89 ec mov %ebp,%esp 12: 5d pop %ebp 13: c3 ret 45 m.c int e=7; int r = a(); exit(); a.c extern int e; int *ep=&e; int x=15; int y; int a() return *ep+x+y; 46 6

7 Merging Relocatable Object Files m.o Relocatable Object Files system code system data main() int e = 7 a() a.o int *ep = &e int x = 15 int y.bss Executable Object File headers system code main() a() more system code system data int e = 7 int *ep = &e int x = 15 uninitialized data.symtab.debug.bss 47 m.o RelocaHon InformaHon m.c int e=7; int r = a(); exit(); objdump d objdump D objdump r objdump - R Disassembly of section : <e>: : 7 pop %es 1: add %al,(%eax) : 55 push %ebp 1: 89 e5 mov %esp,%ebp 1a: 29 c4 sub %eax,%esp 1c: e8 fc ff ff ff call 1d <main+x1d> 1d: R_386_PC32 a 21: fc mov %eax xfffffffc(%ebp) 24: c movl $x,(%esp) 2b: e8 fc ff ff ff call 2c <main+x2c> 2c: R_386_PC32 exit Relocation records for []: OFFSET TYPE VALUE 1d R_386_PC32 a 2c R_386_PC32 exit 48 a.o RelocaHon Info () a.c extern int e; int *ep=&e; int x=15; int y; int a() return *ep+x+y; Disassembly of section : <a>: : 55 push %ebp 1: 89 e5 mov %esp,%ebp 3: a1 mov x,%eax 4: R_386_32 ep 8: 8b 1 mov (%eax),%edx a: a1 mov x,%eax b: R_386_32 x f: 1 c2 add %eax,%edx 11: a1 mov x,%eax 12: R_386_32 y 16: 8d 4 2 lea (%edx,%eax,1),%eax 19: 5d pop %ebp 1a: c3 ret a.o RelocaHon Info () a.c extern int e; int *ep=&e; int x=15; int y; int a() return *ep+x+y; <ep>: : add %al,(%eax) : R_386_32 e 4 <x>: 4: f sldtl (%eax)... Relocation records for []: OFFSET TYPE VALUE 4 R_386_32 ep b R_386_32 x 12 R_386_32 y Relocation records for []: OFFSET TYPE VALUE R_386_32 e 49 5 Executable Object File Executable Object File m.c int e=7; int r = a(); exit(); a.c extern int e; int *ep=&e; int x=15; int y; int a() return *ep+x+y; Disassembly of section : 8495a8 <e>: 8495a8: 7 pop %es 8495a9: add %al,(%eax) ac <ep>: 8495ac: a8 95 test $x95,%al 8495ae: 4 8 add $x8,%al 8495b <x>: 8495b: f sldtl (%eax) <main>: 84837: e8 f call <a> : fc mov %eax,xfffffffc(%ebp) : c movl $x,(%esp) 84837f: e8 1c ff ff ff call 8482a <exit@plt> gcc m.o a.o objdump - d <a>: : a1 ac mov x8495ac,%eax 84838c: 8b 1 mov (%eax),%edx 84838e: a1 b mov x8495b,%eax : 1 c2 add %eax,%edx : a1 b mov x8495b8,%eax 84839a: 8d 4 2 lea (%edx,%eax,1), %eax 52 7

8 Strong and Weak Symbols Linker s Symbol Rules Program symbols are either strong or weak Rule 1: A strong symbol can only appear once. strong: procedures and ini<alized global variables weak: unini<alized global variables strong strong p1.c int foo=5; p1() p2.c int foo; p2() weak strong Rule 2: A weak symbol can be overridden by a strong symbol of the same name. references to the weak symbol resolve to the strong symbol. Rule 3: If there are mul<ple weak symbols, pick an arbitrary one. Can override this with gcc fno-common Linker Puzzles int x; p1() p1() int x; p1() int x; int y; p1() int x=7; int y=5; p1() int x=7; p1() int x; p2() double x; p2() double x; p2() int x; p2() Link time error: two strong symbols (p1) References to x will refer to the same uninitialized int. Is this what you really want? Writes to x in p2 might overwrite y! Evil! Writes to x in p2 will overwrite y! Nasty! References to x will refer to the same initialized variable. Nightmare scenario: two identical weak structs, compiled by different compilers with different alignment rules. 59 Role of.h Files c1.c #include "global.h" int f() return g+1; c2.c #include <stdio.h> #include "global.h" global.h if (!init) g = 37; int t = f(); printf("calling f yields %d\n", t); return ; #ifdef INITIALIZE int g = 23; static int init = 1; #else int g; static int init = ; #endif 6 Running Preprocessor c1.c #include "global.h int f() return g+1; -DINITIALIZE global.h #ifdef INITIALIZE int g = 23; static int init = 1; #else int g; static int init = ; #endif no inihalizahon Variables Avoid if you can Otherwise Use static if you can IniHalize if you define a global variable Use extern if you use external global variable int g = 23; static int init = 1; int f() return g+1; int g; static int init = ; int f() return g+1; #include causes C preprocessor to insert file verbahm

9 Three Kinds of Object Files Relocatable object file (.o file) Contains code and data in a form that can be combined with other relocatable object files to form executable object file. Each.o file is produced from exactly one source (.c) file Executable object file (a.out file) Contains code and data in a form that can be copied directly into memory and then executed. Shared object file (.so file) Special type of relocatable object file that can be loaded into memory and linked dynamically, at either load Hme or run- Hme. Called Dynamic Link Libraries (DLLs) by Windows 7 Packaging Commonly Used FuncHons How to package funchons commonly used by programmers? Math, I/O, memory management, string manipulahon, etc. Awkward, given the linker framework so far: OpHon 1: Put all funchons in a single source file Programmers link big object file into their programs Space and me inefficient Any minor change needs to recompile the whole thing. OpHon 2: Put each funchon in a separate source file Programmers explicitly link appropriate binaries into their programs More efficient, but burdensome on the programmer Need to track each funcon used 71 Packaging Commonly Used FuncHons SoluHon: stahc libraries (.a archive files) Concatenate related relocatable object files Concatenate into a single file with an index, a.k.a. archive Enhance linker Linker tries to resolve unresolved external references Linker looks for the symbols in one or more archives. If an archive member file resolves reference, link into executable CreaHng StaHc Libraries atoi.c Translator atoi.o C standard library printf.c Translator printf.o Archiver (ar) libc.a random.c... Translator random.o ar rs libc.a atoi.o printf.o random.o r: replace the module, otherwise error s: create index for the archive 72 q Archiver allows incremental updates q Recompile function that changes and replace.o file in archive. 73 Commonly Used Libraries Linking with StaHc Libraries libc.a (the C standard library) I/O, memory allocaon, signal handling, string handling, data and me, random numbers, integer math libm.a (the C math library) floang point math (sin, cos, tan, log, exp, sqrt, ) ar t display a table lisng the content of archive % ar -t /usr/lib/libc.a sort fork.o fprintf.o fpu_control.o fputc.o freopen.o fscanf.o fseek.o fstab.o % ar -t /usr/lib/libm.a sort e_acos.o e_acosf.o e_acosh.o e_acoshf.o e_acoshl.o e_acosl.o e_asin.o e_asinf.o e_asinl.o 74 main2.c vector.h Translators (cpp, cc1, as) Relocatable object files main2.o multmat.o addmat.o Archiver (ar) libmat.a Linker (ld) p2 addvec.o libc.a Fully linked executable object file Sta<c libraries printf.o and any other modules called by printf.o 75 9

10 Using StaHc Libraries Loading Executable Binaries Linker s algorithm for resolving external references: Scan.o files and.a files in command line order. During the scan, keep a list of the current unresolved references. As each new.o or.a file obj is encountered, try to resolve each unresolved reference in the list against the symbols in obj. If any entries in the unresolved list at the end of scan, then error. Executable object file for example program p Program header table (required for executables) Problem: section segment x Command line order maoers! section (r/o) Moral: put libraries at the end of the command line..bss section.symtab segment x84a1 lind4-14:/tmp> gcc -m32 c #-c compile, no link (initialized r/w).rel lind4-14:/tmp> gcc -m32 c #-m32 x86-32 lind4-14:/tmp> ar -q libswap.a swap.o #-q quick append.rel x84a3b lind4-14:/tmp> gcc -L. -m32 main.o lswap #-l swap for linking lind4-14:/tmp> gcc -L. -m32 lswap main.o #-L. search directory.debug.bss segment (uninitialized r/w) main.o: In function `main': Section header table :(+x7): undefined reference to `swap' (required for relocatables) collect2: ld returned 1 exit status Process image init and shared lib segments Virtual addr x8483e Loading Executable Object Files Executable Object File Program header table (required for executables).init sechon sechon sechon.symtab.debug.line.strtab SecHon header table (required for relocatables) x1 xf7e9ddc x848 Kernel virtual memory User stack (created at runhme) Memory- mapped region for shared libraries Run- Hme heap (created by malloc) Read/write segment (,.bss) Read- only segment (.init,,.rodata) Unused Memory outside 32- bit address space %esp (stack pointer) brk Loaded from the executable file Shared Libraries StaHc libraries have the following disadvantages: Duplicaon in the stored executables (every funcon need std libc) Duplicaon in the running executables Minor bug fixes of system libraries require each applicaon to explicitly relink Modern soluhon: Shared Libraries Object files that contain code and data that are loaded and linked into an applicaon dynamically, at either load- -me or run- -me Also called: dynamic link libraries, DLLs,.so files Shared Libraries (cont.) Dynamic linking can occur when executable is first loaded and run (load- Hme linking). Common case for Linux, handled automacally by the dynamic linker (ld-linux.so). Standard C library (libc.so) usually dynamically linked. Dynamic linking can also occur amer program has begun (run- Hme linking). In Linux, this is done by calls to the dlopen() interface. Distribung socware. High- performance web servers. Runme library interposioning. Shared library rouhnes can be shared by mulhple processes. 8 Dynamic Linking at Load- Hme Relocatable object file Par<ally linked executable object file Fully linked executable in memory main2.c Translators (cpp, cc1, as) main2.o p2 vector.h Loader (execve) Linker (ld) libc.so libvector.so libc.so libvector.so Dynamic linker (ld-linux.so) unix> gcc -shared -o libvector.so \ addvec.c multvec.c Reloca<on and symbol table info Code and data 81 1

11 Dynamic Linking at Run- Hme Dynamic Linking at Run- Hme #include <stdio.h> #include <dlfcn.h> int x[2] = 1, 2; int y[2] = 3, 4; int z[2]; void *handle; void (*addvec)(int *, int *, int *, int); char *error; /* get a pointer to the addvec() function we just loaded */ addvec = dlsym(handle, "addvec"); if ((error = dlerror())!= NULL) fprintf(stderr, "%s\n", error); exit(1); /* Now we can call addvec() just like any other function */ addvec(x, y, z, 2); printf("z = [%d %d]\n", z[], z[1]); /* unload the shared library */ /* dynamically load the shared lib that contains addvec() */ if (dlclose(handle) < ) handle = dlopen("./libvector.so", RTLD_LAZY); fprintf(stderr, "%s\n", dlerror()); if (!handle) exit(1); fprintf(stderr, "%s\n", dlerror()); exit(1); return ; The Complete Picture m.c Translators (cc1, as) m.o Partially linked executable p (on disk) Fully linked executable p (in memory) a.c Translators (cc1,as) a.o Linker (ld) Shared library of dynamically p libwhatever.so relocatable object files Loader/Dynamic Linker P libwhatever.a libc.so functions called by m.c and a.c are loaded, linked, and shared among processes. 84 RelocaHon Info (main) int buf[2] = 1,2; return ; Source: objdump r -d main.o <main>: : 8d 4c 24 4 lea x4(%esp),%ecx 4: 83 e4 f and $xfffffff,%esp 7: ff 71 fc pushl xfffffffc(%ecx) a: 55 push %ebp b: 89 e5 mov %esp,%ebp d: 51 push %ecx e: 83 ec 4 sub $x4,%esp 11: e8 fc ff ff ff call 12 <main+x12> 12: R_386_PC32 swap 16: 83 c4 4 add $x4,%esp 19: 31 c xor %eax,%eax 1b: 59 pop %ecx 1c: 5d pop %ebp 1d: 8d 61 fc lea xfffffffc(%ecx),%esp 2: c3 ret Disassembly of section : <buf>: : RelocaHon Info (swap, ) int *bufp = &buf[]; temp = *bufp; *bufp = *bufp1; swap.o Disassembly of section : <swap>: : 8b 15 mov x,%edx 2: R_386_32 buf 6: a1 4 mov x4,%eax 7: R_386_32 buf b: 55 push %ebp c: 89 e5 mov %esp,%ebp e: c7 5 4 movl $x4,x 15: 1: R_386_32.bss 14: R_386_32 buf 18: 8b 8 mov (%eax),%ecx 1a: 89 1 mov %edx,(%eax) 1c: 5d pop %ebp 1d: 89 d 4 mov %ecx,x4 1f: R_386_32 buf 23: c3 ret 86 RelocaHon Info (swap, ) int *bufp = &buf[]; temp = *bufp; *bufp = *bufp1; Disassembly of section : <bufp>: : : R_386_32 buf 87 11

12 Executable Before/Amer RelocaHon () <main>: e: 83 ec 4 sub $x4,%esp 11: e8 fc ff ff ff call 12 <main+x12> 12: R_386_PC32 swap 16: 83 c4 4 add $x4,%esp x x1a = x8483b <main>: 84838: 8d 4c 24 4 lea x4(%esp),%ecx : 83 e4 f and $xfffffff,%esp : ff 71 fc pushl xfffffffc(%ecx) 84838a: 55 push %ebp 84838b: 89 e5 mov %esp,%ebp 84838d: 51 push %ecx 84838e: 83 ec 4 sub $x4,%esp : e8 1a call 8483b <swap> : 83 c4 4 add $x4,%esp : 31 c xor %eax,%eax 84839b: 59 pop %ecx 84839c: 5d pop %ebp 84839d: 8d 61 fc lea xfffffffc(%ecx),%esp 8483a: c3 ret 88 : 8b 15 mov x,%edx 2: R_386_32 buf 6: a1 4 mov x4,%eax 7: R_386_32 buf... e: c7 5 4 movl $x4,x 15: 1: R_386_32.bss 14: R_386_32 buf 1d: 89 d 4 mov %ecx,x4 1f: R_386_32 buf 23: c3 ret 8483b <swap>: 8483b: 8b mov x84962,%edx 8483b6: a mov x849624,%eax 8483bb: 55 push %ebp 8483bc: 89 e5 mov %esp,%ebp 8483be: c movl $x849624,x c5: c8: 8b 8 mov (%eax),%ecx 8483ca: 89 1 mov %edx,(%eax) 8483cc: 5d pop %ebp 8483cd: 89 d mov %ecx,x d3: c3 ret 89 Executable Amer RelocaHon () RelocaHng Symbols and Resolving References Disassembly of section : <buf>: 84962: <bufp>: : Def of global symbol e Symbols are lexical enes that name funcons and variables. Each symbol has a value (typically a memory address). Code consists of symbol defini-ons and references. References can be either local or external. Ref to external symbol exit (defined in libc.so) m.c int e=7; int r = a(); exit(); Ref to external symbol a Def of gloabl symbol ep a.c extern int e; int *ep=&e; int x=15; int y; int a() return *ep+x+y; Def of global symbol a Refs of global symbols ep,x,y Ref to external symbol e Defs of global symbols x and y 91 12