I take it you’re using Jeff Darcy’s definitions:
- static linking involves resolving symbols at compile time, whereas dynamic linking involves resolving them at run time;
- static loading involves mapping executables and libraries at load time, whereas dynamic loading involves mapping libraries after the process has started.
It doesn’t really make sense to try to split everything up; instead, you should consider the pairs of features:
- static loading, static linking: the linker is
/usr/bin/ld typically, along with static libraries (
.a); the loader is the kernel;
- static loading, dynamic linking: the linker is
/usr/bin/ld again, but with shared libraries (
.so); the loader is the binary’s interpreter, e.g.
/lib64/ld-linux-x86-64.so.2 (which maps to
/lib/x86_64-linux-gnu/ld-2.24.so currently) on Debian 9 on 64-bit x86, itself loaded by the kernel, which also loads the main executable;
- dynamic loading, static linking: this isn’t used on Linux as far as I’m aware;
- dynamic loading, dynamic linking: the loader is a library such as
libdl; the linker is split between the library and the program calling
Perhaps some more explanation is called for in relation to the last point. When a program uses
libdl to load a library, it calls
dlopen, which loads the named library, along with any of its dependencies which aren’t already available in the process, and links the named library with its dependencies. Thus
libdl performs both loading (of the necessary libraries) and linking (of the libraries only, not the calling program). When the calling program needs to use a symbol from the named library, it calls
dlsym which returns the address of the requested symbol (if it can find it). Thus the calling program performs part of the linking.
There is no chicken-and-egg problem with regards to
dlopen. Programs compiled to use
execve are compiled with the appropriate references to
libc (which contains the wrapper most programs actually use) and the
execve symbol (strictly speaking, the aforementioned wrapper). Those references are resolved either at compile-time (for statically-linked programs) or at load-time (for dynamically-linked programs); after that, the symbol is available for use and the program can call
execve. The same goes for
dlopen: programs which want to use
dlopen are compiled with the appropriate references to
dlopen. The dynamic linker itself is a static binary, so the kernel can load it without the help of the dynamic linker. You’ll find lots more detail on this topic in How programs get run and How programs get run: ELF binaries.
(Note that in all cases of dynamic linking, if lazy binding is enabled, linking can happen just-in-time, and not necessarily at load time.)