Understand and Implement Dynamic Linking

Topic Overview

Late Binding with Shared Libraries

Dynamic linking loads .so / .dylib / .dll at runtime. PLT and GOT on x86-64 redirect external calls through stubs resolved on first call. ld.so maps libraries and performs relocations. Most Linux programs dynamically link libc.

PLT/GOT Mechanism

First call printf jumps through PLT stub to GOT entry pointing at resolver. Resolver patches GOT with real printf address; later calls go direct.

cCopy
Loading…

• -fPIC generates position-independent code
• -shared builds shared objects
• dlopen loads libraries at runtime manually
• Symbol visibility: default, hidden, protected

Connecting to real compilers

Production compilers embed this step inside a longer pipeline. GCC flows through cpp, cc1, assembly, and ld; Clang uses the driver, Sema, LLVM IR passes, and a target backend. LLVM bitcode, JVM bytecode, and WASM are other familiar IRs at the same layer. The exercise isolates one pass so you can test it alone before chaining it to the next stage.

Why for this exercise

You will understand and implement dynamic linking concepts. This exercise asks you to model GOT/PLT indirection and runtime symbol resolution for external function calls.

Your Task

Simulate how a dynamically linked program calls shared-library functions through the PLT and GOT, including lazy binding (resolve on first call, then patch the GOT) and LD_BIND_NOW-style eager binding.

Input

cCopy
Loading…

The model

• Import k (0-based) owns PLT entry k+1 at 0x401020 + 16·(k+1) and GOT slot k+3 at 0x404000 + 8·(k+3) (slots 0-2 are reserved for the dynamic linker).
• Lookup of a symbol searches libraries in load order; the first library that exports it wins (symbol interposition). Its address is base + offset.
• lazy: every GOT slot initially holds its own PLT entry's address + 6 (the push instruction after the indirect jmp), so the first call falls into the resolver, which looks the symbol up and patches the slot. Later calls jump straight to the function.
• now: before any call, every import is looked up in order and its GOT slot filled; print bind SYMBOL -> LIB 0xADDR for each.
• An import that no library exports is fatal: at startup in now mode, at its first call in lazy mode: print fatal: symbol lookup error: undefined symbol: SYMBOL and stop.
• Calling a symbol that was never imported is fatal too: fatal: SYMBOL has no PLT entry.

Output

For every call:

cCopy
Loading…

(lazy when the slot still points back into the PLT, bound when it holds the function's address.) Finish with resolver-calls=R bound-calls=B: also printed after a fatal error.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. A GOT array holding the current target of each slot; the "call" logic only reads and patches it.
2. One lookup function shared by lazy resolution and eager binding.

Hidden tests cover interposition (the same symbol in two libraries, where load order decides), an import that is never called, and an undefined import that is only discovered at its first call in lazy mode.