Detailed explanation of Linux dynamic library generation and usage guide

The file name of the dynamic library file under Linux is like libxxx.so, where so is the abbreviation of Shared Object, that is, the target file that can be shared.

When linking a dynamic library to generate an executable file, the code of the dynamic library is not copied to the executable file, but a reference to the dynamic library is recorded in the executable file.

When the program is executed, the dynamic library file is loaded. If the dynamic library has already been loaded, it does not need to be loaded again, thus saving memory space.

The steps to generate and use dynamic libraries under Linux are as follows:

• Write the source file.
• Compile and link one or several source files to generate a shared library.
• Link the generated libxxx.so via the gcc option -L<path> -lxxx
• Put libxxx.so into the standard path of the link library, or specify LD_LIBRARY_PATH, in order to run the program linked to libxxx.so.

The following is a detailed explanation through examples.

Writing source files

Create a source file: max.c, the code is as follows:

int max(int ​​n1, int n2, int n3)
{
  int max_num = n1;
  max_num = max_num < n2? n2: max_num;
  max_num = max_num < n3? n3: max_num;
  return max_num;
}

Compile and generate a shared library:

gcc -fPIC -shared -o libmax.so max.c

We will get libmax.so.

In fact, the above process is divided into two steps: compilation and linking. -fPIC is the compilation option. PIC is the abbreviation of Position Independent Code, which means that position-independent code should be generated, which is a feature required by dynamic libraries. -shared is the linking option, which tells gcc to generate a dynamic library instead of an executable file.

The above command line is equivalent to:

gcc -c -fPIC max.c
gcc -shared -o libmax.so max.o

Writing interface files for dynamic libraries

In order to let users know which interfaces are available in our dynamic library, we need to write the corresponding header files.

Create max.h and enter the following code:

#ifndef __MAX_H__
#define __MAX_H__

int max(int ​​n1, int n2, int n3);

#endif

Test, link dynamic library to generate executable file

Create a test.c file that uses the max function. The code is as follows:

#include <stdio.h>
#include "max.h"

int main(int argc, char *argv[])
{
  int a = 10, b = -2, c = 100;
  printf("max among 10, -2 and 100 is %d.\n", max(a, b, c));
  return 0;
}

gcc test.c -L. -lmax generates a.out, where -lmax means to link libmax.so.

-L. Indicates that the current path is included when searching for library files to link.

Note that if there are dynamic and static libraries with the same name in the same directory, for example, libmax.so and libmax.a are both in the current path,
Then gcc will prioritize linking dynamic libraries.

run

Running ./a.out will give the following error message.

./a.out: error while loading shared libraries: libmax.so: cannot open shared object file: No such file or directory

libmax.so cannot be found. It turns out that Linux searches for the dynamic library to be linked through the /etc/ld.so.cache file.
/etc/ld.so.cache is generated by the ldconfig program reading the /etc/ld.so.conf file.
(Note that /etc/ld.so.conf does not have to include /lib and /usr/lib, the ldconfig program will automatically search these two directories)

If we add the path where libmax.so is located to /etc/ld.so.conf, and then run the ldconfig program with root privileges to update /etc/ld.so.cache, a.out will be able to find libmax.so when it runs.

But as a simple test case, it seems inappropriate for us to change things in the system.

There is another simple way, which is to specify LD_LIBRARY_PATH for a.out.

LD_LIBRARY_PATH=. ./a.out

The program will run normally. LD_LIBRARY_PATH=. tells a.out to first look for the linked dynamic library in the current path.

For executable programs in elf format, it is done by ld-linux.so*, which searches the DT_RPATH segment of the elf file, the environment variable LD_LIBRARY_PATH, the /etc/ld.so.cache file list, the /lib/,/usr/lib directory, and loads the library file into memory after finding it.

Makefile automates the work

Write a makefile with the following content:

.PHONY: build test clean

build: libmax.so

libmax.so: max.o
 gcc -o $@ -shared $<

max.o: max.c
 gcc -c -fPIC $<

test: a.out

a.out: test.c libmax.so
 gcc test.c -L. -lmax
 LD_LIBRARY_PATH=. ./a.out

clean:
 rm -f *.o *.so a.out

make build will generate libmax.so, make test will generate a.out and execute it, and make clean will clean up the compilation and test results.

This is the end of this article about the detailed explanation of Linux dynamic library generation and usage guide. For more relevant Linux dynamic library generation content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!