COMPUTING
x86 assembly language is a family of low-level programming notations for the instruction sets descended from Intel's 8086 processor. It exposes registers, memory operands, control flow, flags, and processor extensions more directly than languages such as C or Rust, while assemblers translate its mnemonics into machine-code bytes.
x86 assembly language describes programs for processors in the x86 instruction-set family, rather than one single standardized dialect. The family began with the 16-bit 8086 and expanded through the 80286, IA-32 processors, and x86-64 implementations from AMD and Intel.1 Modern processors generally retain compatibility with earlier instructions while adding execution modes and extensions. In 32-bit protected mode, programs commonly use the IA-32 model; in 64-bit mode, they use x86-64 registers and addressing rules. The instruction set is often called CISC because instructions have variable lengths and can combine operations such as memory access and arithmetic, although contemporary processors translate many instructions internally into simpler micro-operations.
Assembly remains useful when exact control over calling conventions, instruction selection, startup code, or hardware interfaces matters. It is also the notation used to inspect compiler output, reverse-engineer binaries, and explain the machine-level behavior of higher-level programs.
Assembly source is organized around mnemonics, operands, labels, directives, and comments. An instruction such as mov rax, rbx copies a value between registers, while arithmetic and logical instructions update registers and often the condition flags. Memory operands can use a base register, index register, scale, and displacement, such as [rax+rcx*4+8] in Intel-style notation. The same machine instruction may appear differently in AT&T syntax, where operand order and register prefixes differ; GNU as documents that dialect and its directives, while NASM documents a commonly used Intel-style syntax.23
Assemblers also handle symbolic names, sections, alignment, macros, and relocations. A linker combines object files and resolves references, so an assembly source file is normally only one stage of a larger toolchain involving a compiler, assembler, linker, loader, and debugger.
x86 programs operate through registers, memory, flags, and control-transfer instructions. General-purpose registers hold integers and addresses; the instruction pointer selects the next instruction; and the flags register records results used by conditional branches. Separate register families support floating-point and vector computation, including x87, SSE, AVX, and later extensions described in Intel's instruction references.4 Privilege levels, paging, interrupts, and system instructions distinguish application code from operating-system code, and many privileged operations are unavailable to ordinary processes.
Correct assembly must also obey its platform's application binary interface. An ABI specifies argument registers or stack locations, return values, stack alignment, preserved registers, object-file conventions, and sometimes unwind metadata. For example, Microsoft documents a distinct x64 calling convention, while ELF-based systems commonly pair x86-64 code with System V conventions.56 These rules allow assembly to interoperate with compiled languages.
The most consequential details of x86 assembly often concern encoding and compatibility rather than mnemonic names. Instructions are variable-length, and prefixes can alter operand size, address size, repetition, locking, or vector interpretation; this makes decoding more complex than in many fixed-width instruction sets. Some encodings have historically ambiguous or legacy meanings, and assemblers may choose different encodings unless programmers request a particular form.
Performance is likewise context-dependent. A short instruction is not necessarily faster, and throughput, latency, dependencies, branch prediction, cache behavior, and microarchitectural generation all matter. Vector extensions can require attention to register state and operating-system support, while instructions such as cpuid are commonly used to detect features before selecting optimized code.1 Assembly is also central to boot sectors, firmware, context switches, cryptographic primitives, JIT compilers, and binary instrumentation—areas where relocation, alignment, unwinding, or privilege boundaries can matter more than arithmetic speed.
Instruction availability, syntax, ABI rules, and performance depend on the processor mode, operating system, assembler, linker, and target platform.
Help improve the encyclopedia. Reports go straight to the site manager.