A few questions on linking concepts.

[dE_logics]

1) To use a library's components, you just have to declare the function/variable in your program?... that's it? Same procedure for static and dynamic libraries?

2) Is manual library loading (in the program) a common practice even now? Or is it that libraries are loaded and unloaded by the OS automatically on demand (while running a single program)? For e.g. if I require the function X which happens to be in libX.so, then will the library be loaded just before the call and unloaded after the call? Can such programs be compiled statically?

3) How is the location of the static library determined?
3.1) At run time (dynamic linker)
3.2) At compile time (static linking)
I know about /etc/ld.so.conf, but then also, does the linker test each library for the target function?

4) In static and dynamic linking (compile time), do we need the source of the linked libraries? If so, where are they placed?

5) There are 2 kinds of dynamic libraries, one is statically aware (library loaded as program starts) and the other is dynamic loading type where you have to manually load and unload libraries in the program in order to use them.
Are these 2 completely different kind of libraries, or is the methods of linking different? e.g. if I want to link my program to libX.so dynamically, then can I link it in a 'statically aware' or 'dynamic loading' way with the same libX.so?

Thanks for clarifying!
_________________
Buy from companies supporting opensource -- IBM, Dell, HP, Hitachi, Google etc...
Disfavor companies supporting only Win -- Logitech, Epson, Adobe, Autodesk, Pioneer, Kingston, WD, Yahoo, MSI, XFX
My blog

[Genone]

[wcg]

Perhaps this document clarifies some linking issues:
http://www.iecc.com/linker/linker10.html
_________________
TIA

[v_andal]

Yep, first of all, one should understand difference between "dynamic linking" and "static linking". The second (static) puts the code of functions into executable, so the functions are always available. The first (dynamic) just marks in which "library" the code of the function can be found. When the program is started, dynamic linker finds all necessary library files and loads necessary functions into memory.

In both cases, there's no need to worry about library files, the linkers (dynamic or static) take care of this.

There's third case though. One can "manually" load code for some function from dynamic library into memory. This is how different plugins are implemented. When the program is started, it may not know which plugins it shall use. At run-time it obtains name of the library file and the name of the function in that file, then dlopen and Co. are used to load necessary code into memory.

[wcg]

For dynamic linking to code in shared libraries, the whole library
is loaded into memory, and the dynamic linker fixes up references
to static data in the library (errno values, for example) when
the library is loaded, and fixes up references to functions in
the library as they are called. The library will stay in memory
as long as anything linked to it is running. libc.so stays
in memory from when init is started to shutdown if init is
dynamically linked to it.

For the kernel, shared libraries are just another elf executable.
Because it can reload the text (the code) of executables from
persistent storage, under sufficient memory pressure the kernel
will discard unused, then less recently used pages of executables
from memory, reloading them from the executable in storage
if they are accessed by running code. It does this after exhausting
its other resources (installed physical memory, swap, pages
allocated to buffer cache of files that have been loaded, the
directory cache, fragmented pages that can be coalesced
to free up pages of memory, etc; the kernel can jump through
a lot of complex hoops in the time it takes to read a page
from disk, so what seem like extraordinarily complex algorithms
from a coding perspective for freeing pages of memory for
allocation often prove to be "worth it" at runtime).
_________________
TIA

[dE_logics]

Thanks for the clarification everyone, especially Genone; now things are a lot clearer.
_________________
Buy from companies supporting opensource -- IBM, Dell, HP, Hitachi, Google etc...
Disfavor companies supporting only Win -- Logitech, Epson, Adobe, Autodesk, Pioneer, Kingston, WD, Yahoo, MSI, XFX
My blog