C++ Linking In-Depth: Static, Dynamic, and Everything Between

# Examine object file sections
objdump -h main.o

# Typical sections:
# .text    - Machine code
# .data    - Initialized global variables
# .bss     - Uninitialized global variables
# .rodata  - Read-only data (string literals, const)
# .symtab  - Symbol table
# .strtab  - String table
# .rela.*  - Relocation entries

// main.cpp
#include <iostream>

int global_var = 42;        // → .data section
int uninit_var;             // → .bss section
const char* msg = "Hello";  // → .rodata section

void function() {           // → .text section
    std::cout << msg;
}

int main() {               // → .text section
    function();
    return 0;
}

// Strong symbols (definitions)
int x = 10;              // Strong symbol
void func() { }          // Strong symbol

// Weak symbols
int y;                   // Weak symbol (uninitialized global)
__attribute__((weak)) 
int z = 5;              // Explicitly weak symbol

// Undefined symbols (references)
extern int external_var; // Undefined symbol
void external_func();    // Undefined symbol

// Error: Multiple definitions
// file1.cpp
int global = 1;

// file2.cpp
int global = 2;  // Error: multiple definition of 'global'

// Solution: Use static or namespace
static int global = 1;  // File-local
// or
namespace { int global = 1; }  // Anonymous namespace

# Compile object files
g++ -c math_utils.cpp -o math_utils.o
g++ -c string_utils.cpp -o string_utils.o

# Create static library (archive)
ar rcs libutils.a math_utils.o string_utils.o

# View library contents
ar t libutils.a
nm libutils.a

# Link with static library
g++ main.cpp -L. -lutils -o program
# or
g++ main.cpp libutils.a -o program

# Compile with Position Independent Code (PIC)
g++ -fPIC -c math_utils.cpp
g++ -fPIC -c string_utils.cpp

# Create shared library
g++ -shared -o libutils.so math_utils.o string_utils.o

# Or in one step
g++ -fPIC -shared math_utils.cpp string_utils.cpp -o libutils.so

# Link with shared library
g++ main.cpp -L. -lutils -o program

# Set library path for runtime
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./program

# Create versioned library
g++ -shared -Wl,-soname,libutils.so.1 -o libutils.so.1.2.3 *.o

# Create symlinks
ln -s libutils.so.1.2.3 libutils.so.1  # SONAME link
ln -s libutils.so.1 libutils.so         # Development link

# Link against library
g++ main.cpp -lutils -o program

// Without PIC (absolute addressing)
int global = 42;
int* get_global() {
    return &global;  // Address fixed at link time
}

// With PIC (relative addressing)
// Compiler generates:
// - PC-relative addressing for code
// - GOT-relative addressing for data

# Non-PIC (slightly faster, not shareable)
g++ -c file.cpp

# PIC (shareable, required for .so)
g++ -fPIC -c file.cpp

# PIE (Position Independent Executable)
g++ -fPIE -pie main.cpp -o program

# View PLT entries
objdump -d -j .plt program

# View GOT entries
objdump -d -j .got program

# View dynamic relocations
readelf -r program

# Trace dynamic linking
LD_DEBUG=bindings ./program

# Lazy binding (default)
./program

# Immediate binding (resolve all symbols at startup)
LD_BIND_NOW=1 ./program

# Compile with immediate binding
g++ -Wl,-z,now main.cpp -o program

// R_X86_64_64: Absolute 64-bit relocation
void* ptr = &global_var;

// R_X86_64_PC32: PC-relative 32-bit
call function

// R_X86_64_GOT32: GOT-relative
mov rax, variable@GOT

// R_X86_64_PLT32: PLT-relative
call function@PLT

# Relocations in object file
readelf -r main.o

# Dynamic relocations in executable
readelf -r program

# Relocation processing
LD_DEBUG=reloc ./program

# Wrong order (may fail)
g++ -lB -lA main.cpp  # If A depends on B

# Correct order
g++ main.cpp -lA -lB  # Objects first, then dependencies

# Circular dependencies
g++ main.cpp -lA -lB -lA  # Repeat if necessary

# Or use groups
g++ main.cpp -Wl,--start-group -lA -lB -Wl,--end-group

// undefined reference to `function()'
// Causes:
// 1. Missing implementation
void function();  // Declaration only

// 2. Name mangling mismatch
extern "C" void c_function();  // C linkage

// 3. Template instantiation
template<typename T>
void tmpl_func(T t) { }
// Need explicit instantiation or definition in header

// 4. Missing library
// Solution: Add -llibrary flag

// multiple definition of `variable'
// header.h
int var = 10;  // Wrong: Definition in header

// Solutions:
// 1. Use extern declaration
extern int var;  // In header
int var = 10;    // In one .cpp file

// 2. Use inline (C++17)
inline int var = 10;  // In header

// 3. Use static (file-local)
static int var = 10;  // Each translation unit gets its own

# cannot find -llibrary
# Solutions:

# 1. Specify library path
g++ main.cpp -L/path/to/library -llibrary

# 2. Use full path
g++ main.cpp /path/to/library/liblibrary.a

# 3. Update library path
export LIBRARY_PATH=/path/to/library:$LIBRARY_PATH
g++ main.cpp -llibrary

# 4. For runtime
export LD_LIBRARY_PATH=/path/to/library:$LD_LIBRARY_PATH

// Provide default implementation
__attribute__((weak))
void optional_feature() {
    std::cout << "Default implementation\n";
}

// Can be overridden by strong symbol
void optional_feature() {
    std::cout << "Custom implementation\n";
}

// Control symbol visibility in shared libraries
// Default visibility (exported)
__attribute__((visibility("default")))
void public_function();

// Hidden visibility (not exported)
__attribute__((visibility("hidden")))
void internal_function();

// Compile with default hidden
// g++ -fvisibility=hidden -fPIC shared.cpp

/* custom.ld - Custom linker script */
SECTIONS
{
    . = 0x400000;  /* Start address */
    
    .text : {
        *(.text)
    }
    
    .data : {
        *(.data)
    }
    
    .bss : {
        *(.bss)
    }
}

/* Use: g++ main.cpp -T custom.ld */

# Enable LTO
g++ -flto -c file1.cpp
g++ -flto -c file2.cpp
g++ -flto file1.o file2.o -o program

# Whole program optimization
g++ -flto -fwhole-program main.cpp lib.cpp -o program

# Parallel LTO
g++ -flto=auto -O3 *.cpp -o program

# Direct dependencies
ldd program

# Recursive dependencies
ldd -v program

# Unused dependencies
ldd -u program

# Missing symbols
nm -u program

# Library search order
LD_DEBUG=libs ./program

# RPATH (built into executable)
g++ main.cpp -Wl,-rpath,/custom/lib/path -lutils

# Check RPATH
readelf -d program | grep RPATH

# RUNPATH (can be overridden by LD_LIBRARY_PATH)
g++ main.cpp -Wl,--enable-new-dtags,-rpath,/path

# Remove unnecessary dependencies
g++ main.cpp -Wl,--as-needed -lutil1 -lutil2

# GCC/G++ verbose
g++ -v main.cpp -lutils

# Show linker invocation
g++ -### main.cpp

# Linker verbose
g++ -Wl,--verbose main.cpp

# Trace library search
g++ -Wl,--trace main.cpp -lutils

# Show link map
g++ -Wl,-Map=output.map main.cpp

# nm - List symbols
nm -C program          # Demangled C++ symbols
nm -D libshared.so     # Dynamic symbols only
nm -u program          # Undefined symbols

# objdump - Display object information
objdump -t program     # Symbol table
objdump -T program     # Dynamic symbol table
objdump -p program     # Private headers

# readelf - Display ELF information
readelf -s program     # Symbol table
readelf -d program     # Dynamic section
readelf -r program     # Relocations

# c++filt - Demangle symbols
nm program | c++filt

# patchelf - Modify ELF executables
patchelf --set-rpath /new/path program
patchelf --add-needed libneeded.so program

# ELF-specific tools
eu-readelf -a program  # Alternative readelf
elfutils program       # Various ELF utilities

# macOS-specific
otool -L program       # Like ldd
otool -t program       # Text section
install_name_tool -change old.dylib new.dylib program

# Windows/MinGW
objdump -p program.exe | grep DLL  # List DLLs
dumpbin /dependents program.exe    # MSVC

# Prelinking (deprecated but instructive)
prelink -a  # Prelink all system libraries

# Use -fno-plt for direct calls
g++ -fno-plt main.cpp

# Combine multiple .so into one
g++ -shared obj1.o obj2.o obj3.o -o combined.so

# Use static linking for hot paths
# Dynamic for rarely used features