1) Write the program



eg.,



int main (int argc, char *argv[]) {

  printf ("Hello World");

}



2) Compile the program



When the program gets compiled, the compiler realizes that the current compile unit (ie., the simple C program in this case)  has no implementation for printf(), and therefore produces an entry in the object file's symbol table saying that printf()  has an `unresolved reference'. And the compiler generates an object file (.o file) if there were no syntax errors in the  program



3) Link the object file(s)



The next phase is to link the object files to produce an executable. During linking, the static linker (ld) sees the unresolved reference to printf() and searches the available libraries for an implementation for printf(). In general this will be found in the C library (libC on Solaris). Now, the linker has two options:



* It (linker) can take the printf() implementation from the library and copy it into the final executable. The linker then  searches the printf() implemenation for other unresolved references, and again consult the libraries for resolution. This  process will be performed iteratively until all references to the symbols were resolved. This is known as static linking



* If the C library is realized as a `shared library', the linker can simply put a reference to the C library into the final  executable. Still the linker performs symbol resolution checking as above, to determine if the reference to the printf()  function necessiates further references to other (shared or nonshared) libraries. This is known as dynamic linking



4) Run the executable



What happens when you run the executable, depends on whether it was linked statically or dynamically:



* A statically linked executable is self contained. It is loaded into memory. The entry point, whose designation is system  dependent (for eg, the `__main' symbol) is found and called. This entry function, usually provided by the compiler or a  library, performs some setup and initialization and then calls the user-defined main() function and the instructions inside  main() function gets executed



* In a dynamically linked executable, after loading the executable binary into memory, the dynamic linker (ld.so.1) takes control first. It reads the library references to dynamic libraries produced by the static linker, and loads them into memory. It then performs symbol resolution again and updates all references to symbols in the shared library to point to their actual location, which can only be determined at runtime, because the shared libraries might be loaded to different memory locations each time the executable binary gets executed



The dynamic linker also has the option to abort the execution if the dynamic linking fails - for example if the shared  library has been modified, and a reference known to the static linker isn't available any more

Posted by: Giri Mandalika.    # 4:23 PM Tweet