A brief explanation about the static and shared libraries in linux.

1. LIBRARIESLIBRARIES
Ashwanth SAshwanth S

2. LIBRARIES
It is a file containing compiled code that is to be
incorporated later into a program.
It is of two types:
1. Static library
2. Shared library

3. Static Library
● An archive (or static library) is simply a collection of
object files stored as a single file.
● Static libraries end with the ``.a'' suffix. This collection
is created using the ar (archiver) program.
● When the linker encounters an archive on the
command line, it searches the archive for all
definitions of symbols (functions or variables) that are
referenced from the object files that it has already
processed but not yet defined.
● The object files that define those symbols are extracted
from the archive and included in the final executable.

4. Creating a static library
● Compile: gcc -Wall -g -c prog1.c prog2.c
-Wall: include warnings
-g : include debugging info
● Create library:ar rcs libname.a prog1.o prog2.o
● List files in library: ar -t libctest.a

6. ● Linking with the library:
➢ gcc -o executable-name prog.c libname.a
➢ gcc -o executable-name prog.c -L/path/to/library-
directory -lname

8. Shared Library
● A shared library (also known as a shared object, or as
a dynamically linked library) is similar to a archive in
that it is a grouping of object files.
● The most fundamental difference is that when a shared
library is linked into a program, the final executable
does not actually contain the code that is present in the
shared library. Instead, the executable merely contains
a reference to the shared library.

9. Creating a shared library
● Create library:
gcc -Wall -fPIC -c prog1.c prog2.c
gcc -shared -o libname.so prog1.o prog2.o
● You can create a seperate directory for your
shared libraries. Eg /opt/lib where opt is a
directory that is reserved for all the software
and add-on packages that are not part of the
default installation.

10. ● You can move the created shared library to that directory.
Eg: mv libname.so /opt/lib
● If you are creating the library with version number eg
libname.so.x where x is the version number you have to
link the file as shown below.
ln -sf /opt/lib/libname.so.x /opt/lib/libname.so
● The link to /opt/lib/libname.so allows the naming
convention for the compile flag -lctest to work.

12. ● Compile main program and link with shared object
library:
gcc -Wall -o prog prog.c -L/opt/lib -lname
● The shared library dependencies of the executable
can be listed with the command: ldd name-of-
executable
eg: ldd prog

13. ● The output of ldd may show something like
below:
libname.so => not found
● You can fix this by following one of the
method below:
a) export LD_LIBRARY_PATH=/opt/lib

15. b) During compiling you could add rpath as below
gcc -o prog prog.c -L/opt/lib -lname
-Wl,-rpath=/opt/lib
c) You can add the path of the library in
etc/ld.so.conf.d/libc.conf
● To update the cache use
sudo ldconfig

17. ● Now if you check the dependencies the not found
would have disappeared.
● In LD_LIBRARY_METHOD the environmental
variable vanishes once you close the terminal so
you have to specify the path again and again
● In rpath the path is added to the executable so you
dont have to mention it again for that one.

18. ● If you have added the library path in libc.conf the
libraries will be searched there automatically.
● Note:
➢ Suppose that both libname.a and libname.so are
available.Then the linker must choose one of the
libraries and not the other.
➢ The linker searches each directory (first those
specified with -L options, and then those in the
standard directories).

19. ➢ When the linker finds a directory that contains either
libtest.a or libtest.so, the linker stops searching the
directories.
➢ If only one of the two variants is present in the directory,
the linkerchooses that variant.
➢ Otherwise, the linker chooses the shared library version,
unless you explicitly instruct it otherwise.You can use the
-static option to demand static archives.
➢ For example, the following line will use the libname.a
archive, even if the libname.so shared library is also
available:
gcc -static -o prog prog.c -L/opt/lib –lname

20. ● These shared libraries are dynamically linked.
● Even though the dynamic linker does a lot of the work for
shared libraries, the traditional linker still has a role to play
in creating the executable.
● The traditional linker needs to leave a pointer in the
executable so that the dynamic linker knows what library
will satisfy the dependencies at runtime.
● The dynamic section of the executable requires a
NEEDED entry for each shared library that the executable
depends on.

22. ● The dynamic linker is the program that manages
shared dynamic libraries on behalf of an
executable.
● The essential part of the dynamic linker is fixing up
addresses at runtime, which is the only time you
can know for certain where you are loaded in
memory. A relocation can simply be thought of as
a note that a particular address will need to be fixed
at load time.

23. ● Shared libraries can also be loaded at times other than
during the startup of a program. They're particularly
useful for implementing plugins. Eg adobe plugin in
browser..
● To use dynamic loading functions,include the
<dlfcn.h> header file and link with the –ldl option to
pick up the libdl library.

24. Functions in dynamic loaading
● The dlopen function opens a library
void * dlopen(const char *filename, int flag);
eg:
dlopen("/opt/lib/libname.so", RTLD_LAZY);
RTLD_LAZY: If specfied there is no concern
about unresolved symbols until they are
referenced.

25. RTLD_NOW: All unresolved symbols are resolved
when dlopen() is called.
● dlerror()
Errors can be reported by calling dlerror(), which
returns a string describing the error from the last
call to dlopen(), dlsym(), or dlclose(). One point to
note is that after calling dlerror(), future calls to
dlerror() will return NULL until another error has
been encountered.

26. ● dlsym()
The return value from the dlopen function is a void
* that is used as a handle for the shared library.You
can pass this value to the dlsym function to obtain
the address of a function that has been loaded with
the shared library.
● dlclose()
The dlclose function unloads the shared library.

27. ● The executable is created for dynamic loading
as below
gcc -rdynamic -o progdl progdl.c -ldl
● Thus library is dynamically loaded.

28. #include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
#include "ctest.h"
int main(int argc, char **argv)
{
void *lib_handle;
double (*fn)(int *);
int x;
char *error;

29. lib_handle = dlopen("/opt/lib/libctest.so",
RTLD_LAZY);
if (lib_handle==NULL)
{
fprintf(stderr, "%sn", dlerror());
exit(1);
}
fn = dlsym(lib_handle, "ctest1");

30. if ((error = dlerror()) != NULL)
{
fprintf(stderr, "%sn", error);
exit(1);
}
(*fn)(&x);
printf("Valx=%dn",x);
dlclose(lib_handle);
return 0;
}

31. Benefits of Static Libraries
● Static libraries cannot eliminate duplicated
code in the system. However, there are
other benefits to using static libraries. Some
of these benefits are as follows:
● Static libraries are simple to use.
● The static library code does not need to be
position-independent code.

32. Benefits of Shared Libraries
● Code sharing saves system resources.
● Several programs that depend on a common
shared library can be fixed all at once by
replacing the common shared library.
● The environment can be modified to use a
shared library.
● Programs can be written to load dynamic
libraries without any prior arrangement at link
time.