Tag
dynamic-linking
- Sep 26, 2026 Symbol Interposition and the Global Namespace The search order that decides which definition of a name wins, why a shared library cannot rely on its own globals, and how preloading and interposition actually take effect. compilers
- Jul 31, 2026 Position-Independent Code, the PLT, and the GOT Why a shared object cannot know its load address, how the global offset table turns an absolute address into a load-time fixup, and what lazy binding defers. systems programming
- Jul 28, 2026 STT_GNU_IFUNC: Choosing an Implementation at Load Time How a symbol can name a function that returns the address to call, the constraints the resolver runs under, and why the technique trades startup determinism for dispatch without indirection. compilers
- Mar 22, 2026 Remote Debugging Through gdbserver and a Target Sysroot The debugger runs on one machine and the process on another, with only a byte stream between them. Which memory reads the host performs, why the target libraries must exist locally, and what breaks once addresses stop matching. systems programming
- Jan 2, 2026 Symbol Mangling and Linkage in Cross-Language Calls Why C++ and Rust rename functions before the linker sees them, how name mangling differs between compilers, and what dlsym requires of an exported symbol. language runtimes
- Aug 13, 2025 Lazy Binding and the Procedure Linkage Table How the first call to an external function lands in the dynamic linker, what the resolver writes into the GOT, and why eager binding and full RELRO remove the writable page. compilers
- May 23, 2025 SONAME, DT_NEEDED, and Symbol Versioning in Shared Libraries How a shared object records the name it wants to be found under, why DT_NEEDED names a soname rather than a file, and how version definitions keep old binaries working. compilers
- May 10, 2025 Symbol Versioning and the Minimum glibc a Binary Requires Versioned symbols record the library release that first defined each function a binary calls. How that floor is written into the file, why it cannot be lowered after linking, and how to check it before shipping. systems programming
- Jan 17, 2025 The PLT and GOT Protocol That Defers Symbol Resolution How a call to an external function becomes a jump through a writable table, what the resolver stub pushes, and what is given up when binding happens eagerly instead. systems programming
- May 13, 2024 How the PLT and GOT Turn a Library Call Into Writable Memory Lazy binding keeps resolution out of process startup by routing calls through a stub that patches a table, which leaves a writable function pointer for every imported symbol. security
- Apr 26, 2024 Relocation Entries and the Arithmetic a Linker Performs How REL and RELA entries encode the patch a linker must apply, why the addend is sometimes stored in the section and sometimes in the entry, and what R_X86_64_RELATIVE actually computes. systems programming
- Oct 12, 2023 Symbol Versioning and the Two Hash Tables Behind Every Lookup How a symbol name acquires a version suffix at runtime, what SysV and GNU hash tables each optimise for, and why a lookup that succeeds on one distribution can fail on another. systems programming
- Jul 11, 2023 Thread-Local Storage Access Models The four TLS access sequences the compiler can emit, what each costs per access, and why a module loaded after startup cannot use the cheapest ones. compilers
- May 4, 2023 ABI Boundaries as Module Seams in Dynamic Linking What a shared library promises a separately compiled caller, why adding a data member or a virtual function can break that promise, and how symbol visibility turns a design boundary into a loader-enforced one. software architecture