![Linking and Loading 10
CS502 Spring 2006
Dynamic Loading
• Routine is not loaded until it is called
• Better memory-space utilization; unused
routine is never loaded.
• Useful when large amounts of code are
needed to handle infrequently occurring
cases.
• Silbershatz says [incorrectly]
• No special support from the operating system is
required
• Must be implemented through program design](https://image.slidesharecdn.com/wk4-linking-230322151328-74644a19/85/wk-4-linking-ppt-10-320.jpg)
wk 4 -- linking.ppt
- 1. Linking and Loading 1 CS502 Spring 2006 Linking & Loading CS-502 Operating Systems {This topic is not covered in Tannenbaum. Silbershatz et al devote about 2 pages to it in §8.1}
- 2. Linking and Loading 2 CS502 Spring 2006 What happens to your program … …after it is compiled, but before it can be run?
- 3. Linking and Loading 3 CS502 Spring 2006 Executable files • The OS expects executable files to have a specific format – Header info • Code locations • Data locations – Code & data – Symbol Table • List of names of things defined in your program and where they are defined • List of names of things defined elsewhere that are used by your program, and where they are used.
- 4. Linking and Loading 4 CS502 Spring 2006 Example #include <stdio.h> int main () { printf (“hello, worldn”) } • Symbol defined in your program and used elsewhere •main • Symbol defined elsewhere and used by your program •printf
- 5. Linking and Loading 5 CS502 Spring 2006 Example #include <stdio.h> extern int errno; int main () { printf (“hello, worldn”) <check errno for errors> } • Symbol defined in your program and used elsewhere •main • Symbol defined elsewhere and used by your program •printf •errno
- 6. Linking and Loading 6 CS502 Spring 2006 Two-step operation (in most systems) • Linking: Combining a set of programs, including library routines, to create a loadable image a) Resolving symbols defined within the set b) Listing symbols needing to be resolved by loader • Loading: Copying the loadable image into memory, connecting it with any other programs already loaded, and updating addresses as needed – (In Unix) interpreting file to initialize the process address space – (in all systems) kernel image is special (own format)
- 7. Linking and Loading 7 CS502 Spring 2006 From source code to a process • Binding is the process of mapping names to addresses • Most compilers produce relocatable object code • Addresses relative to zero • The linker combines multiple object files and library modules into a single executable file • Addresses also relative to zero • The Loader reads the executable file – Allocates memory – Maps addresses within file to physical memory addresses – Resolves names of dynamic library items Source (.c, .cc) Object (.o) Executable In-memory Image Compiler Linker Loader Other Objects (.o) Dynamic libraries (.dll) Static libraries (.a)
- 8. Linking and Loading 8 CS502 Spring 2006 Static Linking and Loading Printf.c Printf.o Static Library gcc ar Linke r Memory HelloWorld.c gcc HelloWorld.o Loader a.Out (or name of your command)
- 9. Linking and Loading 9 CS502 Spring 2006 Classic Unix • Linker is inside of gcc command • Loader is part of exec system call • Executable image contains all object and library modules needed by program • Entire image is loaded at once • Every image contains copy of common library routines • Every loaded program contain duplicate copy of library routines
- 10. Linking and Loading 10 CS502 Spring 2006 Dynamic Loading • Routine is not loaded until it is called • Better memory-space utilization; unused routine is never loaded. • Useful when large amounts of code are needed to handle infrequently occurring cases. • Silbershatz says [incorrectly] • No special support from the operating system is required • Must be implemented through program design
- 11. Linking and Loading 11 CS502 Spring 2006 Program-controlled Dynamic Loading • Requires: – A load system call to invoke loader (not in Unix/Linux) – ability to leave symbols unresolved and resolve at run time (not in Unix/Linux) • E.g., void myPrintf (**arg) { static int loaded = 0; if (!loaded ) { load (“printf”); loaded = 1; printf(arg); } }
- 12. Linking and Loading 12 CS502 Spring 2006 Linker-assisted Dynamic Loading • Programmer marks modules as “dynamic” to linker • For function call to a dynamic function • Call is indirect through a link table • Each link table initialized with address small stub of code to locate and load module. • When loaded, loader replaces link table entry with address of loaded function • When unloaded, loader replaces table entry with stub address • Static data cannot be made dynamic
- 13. Linking and Loading 13 CS502 Spring 2006 Shared Libraries • Observation – “everyone” links to standard libraries (libc.a, etc.) • Consume space in • every executable image • every process memory at runtime • Would it be possible to share the common libraries? – Automatically load at runtime?
- 14. Linking and Loading 14 CS502 Spring 2006 Shared libraries (continued) • Libraries designated as “shared” • .so, .dll, etc. • Supported by corresponding “.a” libraries containing symbol information • Linker sets up symbols to be resolved at runtime • Loader: Is library already in memory? – If so, map into new process space • “map,” an operation to be defined – If not, load and then map
- 15. Linking and Loading 15 CS502 Spring 2006 Run-time Linking/Loading Printf.c Printf.o Shared Library gcc ar Linker Memory gcc Loader Save disk space. Startup faster. Might not need all. Run-time Loader HelloWorld.c HelloWorld.o a.Out (or name of your command)
- 16. Linking and Loading 16 CS502 Spring 2006 Dynamic Linking • Complete linking postponed until execution time. • Stub used to locate the appropriate memory- resident library routine. • Stub replaces itself with the address of the routine, and executes the routine. • Operating system needs to check if routine is in processes’ memory address space. • Dynamic linking is particularly useful for libraries.
- 17. Linking and Loading 17 CS502 Spring 2006 Dynamic Shared Libraries • Static shared libraries requires address space pre-allocation • Dynamic shared libraries – address binding at runtime – Code must be position independent – At runtime, references are resolved as • Library_relative_address + library_base_address
- 18. Linking and Loading 18 CS502 Spring 2006 Overlays (primarily of historical interest) • Keep in memory only those instructions and data that are needed at any given time. • Needed when process is larger than amount of memory allocated to it. • Can be implemented by user – no special support needed from operating system, but – programming design of overlay structure is complex • Can be done with OS help – think about Unix exec system call
- 19. Linking and Loading 19 CS502 Spring 2006 Linking - Summary • Linker – key part of OS – not in kernel – Combines object files and libraries into a “standard” format that the OS loader can interpret – Resolves references and does static relocation of addresses – Creates information for loader to complete binding process – Supports dynamic shared libraries