System V AMD64 ABI

System V AMD64 ABI
Name	System V AMD64 ABI
Title	System V AMD64 ABI
Developer	AT&T Corporation; UNIX System Laboratories contributors; Intel Corporation; AMD
Released	2000s
Latest release	ongoing
Operating system	Linux, FreeBSD, NetBSD, OpenBSD, Solaris, AIX
Genre	Application binary interface

System V AMD64 ABI The System V AMD64 ABI is an application binary interface specification for 64‑bit x86 processors that standardizes aspects of Linux and other Unix-like platforms, enabling interoperability among compilers, linkers, and runtime components such as GCC, Clang (C language family frontend for LLVM), and GNU C Library. It defines calling conventions, data layout, register usage, and object file semantics used by operating systems including FreeBSD, NetBSD, OpenBSD, and Solaris, and influences Microsoft Windows-adjacent toolchains and porting efforts.

Overview

The specification originated from collaborative work tied to UNIX System Laboratories and later vendor contributions from AMD and Intel Corporation, aligning with standards followed by ecosystems like GNU Project, FSF, and compiler toolchains such as GCC and LLVM Project. It establishes conventions for executables and shared objects interoperable with linkers like GNU Binutils and loaders used by Linux distributions (e.g., Debian, Fedora, Ubuntu). Implementations in operating systems such as FreeBSD and NetBSD rely on the ABI for binary compatibility with userland utilities including the GNU C Library and language runtimes like glibc++ and libstdc++.

Calling conventions

The ABI specifies how functions receive arguments and return values in the context of compilers like GCC and Clang (C language family frontend for LLVM). Integer and pointer arguments are passed in registers such as the ones named by architectures from Intel 64 and AMD64 families; additional arguments are passed on the stack as expected by linkers including ld (GNU linker). Caller-saved and callee-saved register rules are designed to interoperate with exception frameworks in languages implemented by projects such as Mono and Mozilla Firefox's JITs. Optimizations leveraged by compilers for frameworks like Qt and GTK rely on the defined ordering and shadow space semantics used by debuggers such as GDB.

Data types and alignment

The ABI defines widths and alignment for integer types, pointers, and composite types consumed by compilers including Intel C Compiler and Clang. It prescribes layout for structures and unions as used by standard library implementations like musl and GNU C Library, and ensures compatibility with serialization formats used by projects such as OpenSSL and SQLite. Alignment rules affect performance on microarchitectures from AMD Zen and Intel microarchitecture families and guide decisions in systems software such as systemd and hypervisors like QEMU and KVM.

Stack and register usage

Stack frame layout conventions include return address placement compatible with linkers like GNU Gold and unwind information formats compatible with exception mechanisms in LLVM Project's runtimes and GCC-generated code. The ABI names preserved registers that match the register set used by Intel 64 and AMD64 CPUs and coordinates with context-switching code in kernels such as Linux and FreeBSD kernel. Stack alignment requirements are followed by language runtimes including CPython and Ruby interpreters to ensure correct behavior of signal handlers and dynamic loaders like ld.so.

ELF and binary interface specifics

The ABI ties directly into the Executable and Linkable Format (ELF) object model, influencing symbol visibility, relocation types recognized by GNU Binutils, and dynamic linking behavior used by GNU C Library and musl. It specifies sections and attributes that interact with linker scripts authored for ld (GNU linker), and affects packaging policies in distributions such as Red Hat Enterprise Linux and Debian for shared libraries and position-independent executables used by Firefox and Chromium.

Floating-point and SIMD conventions

The specification addresses passing of floating-point values and vector types using register files defined by the x86-64 ecosystem and utilized by compilers like GCC and Clang (C language family frontend for LLVM). It prescribes the ABI for use of SIMD registers introduced by SSE, AVX, and later extensions from Intel Corporation and AMD microarchitectures, which affects numeric libraries such as BLAS implementations, multimedia frameworks like FFmpeg, and machine learning runtimes such as TensorFlow on x86‑64 systems.

Version history and adoption

Adoption evolved through coordination among vendors and open-source communities including GNU Project, NetBSD Foundation, and FreeBSD Foundation, with updates reflecting processor feature additions from AMD and Intel Corporation. Toolchain support in GCC, LLVM Project, and GNU Binutils has ensured broad deployment across server and desktop distributions like Ubuntu, Fedora, and enterprise platforms such as Red Hat Enterprise Linux, as well as in virtualization environments provided by Xen and KVM.

Category:Application binary interfaces