Tag

abi

16 articles

Aug 13, 2026 Wrapping a Native SDK Behind a Shared Interface Third-party SDKs ship as binaries with their own threading, error, and lifecycle models. A plugin boundary has to normalise all three, and the normalisation is where most integration defects originate. mobile computing
Jun 8, 2026 Header Files as an Interface Contract and the ODR Landmine What the ISO C and C++ translation-unit models formalize, how the one-definition rule fails silently when headers disagree, and why the language committee took decades to admit that separate compilation is not composition. computing history
Feb 14, 2026 The C Calling Convention as an Interoperability Contract How arguments, return values, and stack alignment are encoded at a call site, and why extern C is a narrower promise than most callers assume. language runtimes
Jan 9, 2026 Anatomy of a Cross Toolchain: Triples, Sysroots, and Multilibs How a compiler built for one machine produces code for another, what the target triple actually selects, and which ABI mismatches fail at link time versus silently at run time. embedded systems
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
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
Dec 18, 2024 Function Call ABI: Register Assignment on x86-64 How the System V AMD64 ABI classifies arguments into eightbyte chunks, why some structures travel in registers and others on the stack, and what the callee must preserve. systems programming
Nov 8, 2024 Exception Unwinding: Table-Driven Cleanup and the Cost of Try How a raise becomes a search through per-function tables, why some runtimes walk the stack twice, and what the zero-cost claim about exceptions really means. programming languages
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
Aug 3, 2024 Struct Passing and Register Classification Across ABIs How a compiler decides whether a struct travels in registers or in memory, what the eightbyte classification rules encode, and where layouts diverge between C and other languages. language runtimes
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 7, 2023 ISA Families, Extension Levels and Binary Compatibility How architectures partition optional instructions into named levels, how a binary discovers what the current processor implements, and where forward compatibility quietly breaks. computer architecture
Sep 12, 2023 Calling Conventions as Precolored Constraints on the Graph How the ABI fixes which registers hold arguments, returns, and preserved values, and how those obligations enter the interference graph as edges to nodes that already have a color. compilers
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
Jul 28, 2022 Floating-Point ABI Variants and the Linker Errors They Cause Soft, softfp, and hard float on 32-bit ARM decide where arguments travel rather than what arithmetic runs, and only the static linker notices when a build mixes them. systems programming