何时在程序和共享库之间执行动态链接？

Question

In C, when is dynamic linking between a program and a shared library performed:

• Once loading of the program into the memory, but before executing the main() of the program, or

• After executing the main() of the program, when the first call to a routine from the library is executed? Will dynamic linking happen again when a second or third or... call to a routine from the library is executed?

I was thinking the first, until I read the following quote, and now I am not sure.

Not sure if OS matters, I am using Linux.

From Operating System Concepts:

With dynamic linking, a stub is included in the image for each library- routine reference. The stub is a small piece of code that indicates how to locate the appropriate memory-resident library routine or how to load the library if the routine is not already present.

When the stub is executed , it checks to see whether the needed routine is already in memory. If it is not, the program loads the routine into memory. Either way, the stub replaces itself with the address of the routine and executes the routine. Thus, the next time that particular code segment is reached , the library routine is executed directly, incurring no cost for dynamic linking. Under this scheme, all processes that use a language library execute only one copy of the library code.

Answer 1

I was thinking the first, until I read the following quote, and now I am not sure.

It's complicated (and depends on exactly what you call "dynamic linking").

The Linux kernel loads a.out into memory. It then examines PT_INTERP segment (if any).

If that segment is not present, the binary is statically linked and the kernel transfers control to the Elf{32,64}Ehdr.e_entry (usually the _start routine).

If the PT_INTERP segment is present, the kernel loads it into memory, and transfers control to it's .e_entry . It is here that the dynamic linking begins .

The dynamic loader relocates itself, then looks in a.out s PT_DYNAMIC segment for instructions on what else is necessary.

For example, it will usually find one or more DT_NEEDED entries -- shared libraries that a.out was directly linked against. The loader loads any such libraries, initializes them , and resolves any data references between them.

IF a.out s PT_DYNAMIC has a DT_FLAGS entry, and IF that entry contains DF_BIND_NOW flag, then function references from a.out will also be resolved. Otherwise (and assuming that LD_BIND_NOW is not set in the environment), lazy PLT resolution will be performed (resolving functions as part of first call to any given function). Details here .

When the stub is executed, it checks to see whether the needed routine is already in memory. If it is not, the program loads the routine into memory.

I don't know which book you are quoting from, but no current UNIX OS works that way.

Answer 2

The OS (and compiler, etc. ) certainly matters: the language itself has nothing to say about dynamic libraries (and very little about linking in general). Even if we know that dynamic linking is occurring, a strictly-conforming program cannot observe any effect from timing among its translation units (since non-local initialization cannot have side effects ).

That said, the common toolchains on Linux do support automatic initialization upon loading a dynamic library (for implementing C++, among other things). Executables and the dynamic libraries on which they depend (usually specified with -l ) are loaded and initialized recursively to allow initialization in each module to (successfully) use functions from its dependencies. (There is an unfortunate choice of order in some cases.) Of course, dlopen(3) can be used to load and initialize more libraries later.