Tag

elf

21 articles

Oct 20, 2026 Sections, Symbols, and Relocations in an ELF Object File Why a compiled object file is more than machine code: the section header table, the symbol table and its string table, and the relocation records a linker consumes. compilers
Sep 22, 2026 Mapping Sampled Addresses Back to Functions and Source Lines A sample records a virtual address; turning it into a function name, a file, and a line number requires load addresses, symbol tables, and debug information that frequently disagree. performance engineering
Sep 10, 2026 From execve to _start: How the Kernel Maps an ELF Executable Program headers rather than section headers drive loading, PT_LOAD segments carry permissions, PT_INTERP names the dynamic linker, and the kernel hands over a stack with argc, argv, and auxv. compilers
Jun 3, 2026 DWARF Debug Information: Abbreviation Tables and the Line Number State Machine How debug sections compress a typed tree of entries into a byte stream, why attribute forms matter, and how a line table is reconstructed by running a small virtual machine over its opcodes. 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
Nov 10, 2025 Relocation Arithmetic: Patching Machine Code at Link Time The formulas behind absolute, PC-relative, and GOT-relative relocations, the range limits that make them fail, and why the addend must be stored separately on some architectures. compilers
May 10, 2025 Build Identifiers and Separate Debug Information How a 160-bit hash in a note section binds a stripped binary to its symbols, and how debuggers find the matching file through debuglink paths and symbol servers. systems programming
May 10, 2025 Linker Scripts: Why Sections Have Two Addresses How a linker script assigns load and virtual addresses, why initialised data needs a copy step at startup, and what happens to sections the script does not mention. embedded systems
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
May 9, 2025 Build IDs, Separate Debug Files, and Symbol Resolution at Scale How an address in a stripped production binary becomes a function name, why the build ID is the identity that makes it possible, and where symbolication pipelines lose information. observability
Mar 26, 2025 Section Headers, String Tables, and the Bookkeeping a Linker Needs What the section table adds that segments do not carry, how names are resolved through a string table by offset, and why a stripped binary can still run without it. systems programming
Mar 7, 2025 Core Dumps: Notes, Mappings, and Unwinding a Dead Process A core file is an ELF object whose segments are memory rather than code. How registers, mappings, and file identities are recorded so a backtrace can be rebuilt later. developer tools
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
Oct 18, 2024 Parsing Untrusted Binaries Without Trusting Their Length Fields Why every offset in an executable is an attacker-controlled integer, how a bounded cursor converts that into a single failure path, and which structural checks the formats leave to the reader. systems programming
Sep 2, 2024 Reading a Target Triple as an ABI Contract What each field of a target triple selects, how GCC and Clang disagree about defaults, and why two triples naming the same CPU can produce objects that refuse to link. systems programming
May 31, 2024 ELF Program Headers and the Mapping a Loader Performs Before _start How PT_LOAD entries describe the bytes the kernel maps, why file offsets and virtual addresses must be congruent modulo the page size, and where the process stack layout comes from. systems programming
May 9, 2024 Reading an ELF Image: Sections, Symbols, and DWARF How a debugger maps a source line to a flash address, what the symbol table contributes that DWARF does not, and why a stripped image still debugs correctly. embedded systems
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
Apr 8, 2024 Position-Independent Executables and the Cost of PC-relative Addressing Why a PIE carries relocation tables that a fixed-address executable does not, how RIP-relative instructions encode the same reference, and what the GOT still has to mediate. systems programming
Jan 24, 2024 What an ELF Core File Preserves of a Process How the kernel encodes a dead process as an ELF object: loadable segments for memory, note records for registers and mappings, and what the dump deliberately leaves out. 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